import java.util.*;

public class test {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }


    public static void testSwap() {
        int a = 1;
        int b = 2;
        swap(a, b);
        System.out.println("a is " + a + " b is " + b);
    }

    public static void swap(int a, int b) {
        a = a + b;
        b = a - b;
        a = a - b;
    }

    public static void testFun() {
        int n = 10;
        test(n);
        System.out.println(" main n :" + n);
    }

    public static void test(int n) {
        n++;
        System.out.println("test n :" + n);
    }


    public static void TestSort() {
        Random random = new Random();
        random.nextInt();
        int n = 10;
        int maxVal = 100;
        int[] arr = RandomUtil.getIntRandomArray(n, maxVal);
        ArrayList<Integer> list = new ArrayList<>();
        Arrays.asList(arr);
    }


    public static int findMaxValue(int[] nums) {
        // 1. 检查输入数组是否为空，为空则返回最小值
        if (nums == null || nums.length == 0) {
            return Integer.MIN_VALUE;
        }
        // 2. 初始化最大值为数组的第一个元素
        int maxValue = nums[0];
        // 3. 遍历数组中的每个元素
        for (int i = 1; i < nums.length; i++) {
            // 如果当前元素大于已知的最大值，则更新最大值
            if (nums[i] > maxValue) {
                maxValue = nums[i];
            }
        }
        // 4. 返回找到的最大值
        return maxValue;
    }

    class RandomUtil {
        public static int[] getIntRandomArray(int n, int maxVal) {
            Random random = new Random();
            int[] ans = new int[n];
            for (int i = 0; i < n; i++) {
                ans[i] = random.nextInt(maxVal);
            }
            return ans;
        }
    }

    private static void testJVMMemory() {
        // 获取JVM可以使用得内存
        long maxMemory = Runtime.getRuntime().maxMemory();
        // 获取JVM初始化总内存
        long totalMemory = Runtime.getRuntime().totalMemory();
        System.out.println("maxMemory:" + maxMemory / 1024 / 1024 + "M");
        System.out.println("totalMemory:" + totalMemory / 1024 / 1024 + "M");
    }


    public static void main(String[] args) {
        int a = 0x12;
        int b = 012;
        System.out.println("a is " + a + " b is " + b);
        System.out.printf("a binary is %s\n", Integer.toBinaryString(a));
        boolean flag = true;
        if (flag = false) {
            System.out.println("flag is false");
        } else if (!flag) {
            System.out.println("flag is false");
        }
        System.out.println(Runtime.getRuntime().availableProcessors());
        System.out.println("Test sort run...");
//        TestSort();
        testFun();
        testSwap();
        testJVMMemory();
        System.out.println("---------------------------------------------------------------");
    }

    class Solution {
        public int maxDistinctElements(int[] nums, int k) {
            Arrays.sort(nums);
            int ans = 0;
            int pre = Integer.MIN_VALUE;
            for (int x : nums) {
                x = Math.min(Math.max(x - k, pre + 1), x + k);
                if (x > pre) {
                    ans++;
                    pre = x;
                }
            }
            return ans;
        }
    }

/*    class Solution {
        public List<String> removeAnagrams(String[] words) {
            char[] base = words[0].toCharArray();
            Arrays.sort(base);
            int k = 1;
            for (int i = 1; i < words.length; i++) {
                char[] s = words[i].toCharArray();
                Arrays.sort(s);
                if (!Arrays.equals(s, base)) {
                    base = s;
                    words[k++] = words[i];
                }
            }
            return Arrays.asList(Arrays.copyOf(words, k));
        }
    }*/

/*    class Solution {
        private static final int MOD = 1_000_000_007;
        private static final int MX = 31;

        private static final long[] F = new long[MX];
        private static final long[] INV_F = new long[MX];

        static {
            F[0] = 1;
            for (int i = 1; i < MX; i++) {
                F[i] = F[i - 1] * i % MOD;
            }

            INV_F[MX - 1] = pow(F[MX - 1], MOD - 2);
            for (int i = MX - 1; i > 0; i--) {
                INV_F[i - 1] = INV_F[i] * i % MOD;
            }
        }

        private static long pow(long x, int n) {
            long res = 1;
            for (; n > 0; n /= 2) {
                if (n % 2 > 0) {
                    res = res * x % MOD;
                }
                x = x * x % MOD;
            }
            return res;
        }

        public int magicalSum(int m, int k, int[] nums) {
            int n = nums.length;
            int[][] powV = new int[n][m + 1];
            for (int i = 0; i < n; i++) {
                powV[i][0] = 1;
                for (int j = 1; j <= m; j++) {
                    powV[i][j] = (int) ((long) powV[i][j - 1] * nums[i] % MOD);
                }
            }

            int[][][][] f = new int[n + 1][m + 1][m / 2 + 1][k + 1];
            for (int x = 0; x <= m / 2; x++) {
                int c1 = Integer.bitCount(x);
                if (c1 <= k) {
                    f[n][0][x][c1] = 1;
                }
            }

            for (int i = n - 1; i >= 0; i--) {
                for (int leftM = 0; leftM <= m; leftM++) {
                    for (int x = 0; x <= m / 2; x++) {
                        for (int leftK = 0; leftK <= k; leftK++) {
                            long res = 0;
                            for (int j = 0; j <= Math.min(leftM, m - x); j++) {
                                int bit = (x + j) & 1;
                                if (bit <= leftK) {
                                    long r = f[i + 1][leftM - j][(x + j) >> 1][leftK - bit];
                                    res = (res + r * powV[i][j] % MOD * INV_F[j]) % MOD;
                                }
                            }
                            f[i][leftM][x][leftK] = (int) res;
                        }
                    }
                }
            }
            return (int) ((long) f[0][m][0][k] * F[m] % MOD);
        }
    }*/

/*    class Solution {
        public int[] successfulPairs(int[] spells, int[] potions, long success) {
            int mx = 0;
            for (int y : potions) {
                mx = Math.max(mx, y);
            }
            int[] cnt = new int[mx + 1];
            for (int y : potions) {
                cnt[y]++;
            }
            for (int i = mx - 1; i >= 0; i--) {
                cnt[i] += cnt[i + 1];
            }
            for (int i = 0; i < spells.length; i++) {
                long low = (success - 1) / spells[i] + 1;
                spells[i] = low <= mx ? cnt[(int) low] : 0;
            }
            return spells;
        }
    }*/

/*    class Solution {
        public int[] avoidFlood(int[] rains) {
            int n = rains.length;
            int[] ans = new int[n];
            Map<Integer, Integer> fullDay = new HashMap<>();
            TreeSet<Integer> dryDay = new TreeSet<>();
            for (int i = 0; i < n; i++) {
                int lake = rains[i];
                if (lake == 0) {
                    ans[i] = 1;
                    dryDay.add(i);
                    continue;
                }
                Integer j = fullDay.get(lake);
                if (j != null) {
                    Integer d = dryDay.higher(j);
                    if (d == null) {
                        return new int[]{};
                    }
                    ans[d] = lake;
                    dryDay.remove(d);
                }
                ans[i] = -1;
                fullDay.put(lake, i);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public static int[] moved = new int[] { -1, 0, 1, 0, -1 };

        public int swimInWater(int[][] grid) {
            int n = grid.length;
            int m = grid[0].length;
            int[][] distance = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    distance[i][j] = Integer.MAX_VALUE;
                }
            }
            distance[0][0] = grid[0][0];
            boolean[][] visited = new boolean[n][m];
            PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
            pq.add(new int[] { 0, 0, grid[0][0] });
            while (!pq.isEmpty()) {
                int[] record = pq.poll();
                int x = record[0];
                int y = record[1];
                int w = record[2];
                if (visited[x][y]) {
                    continue;
                }
                if (x == n - 1 && y == m - 1) {
                    return w;
                }
                visited[x][y] = true;
                for (int i = 0; i < 4; i++) {
                    int nx = x + moved[i];
                    int ny = y + moved[i + 1];
                    if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
                        int nw = Math.max(w, grid[nx][ny]);
                        if (nw < distance[nx][ny]) {
                            distance[nx][ny] = nw;
                            pq.add(new int[] { nx, ny, nw });
                        }
                    }
                }
            }
            return -1;
        }
    }*/

/*    class Solution {
        private static final int[][] DIRS = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};

        public List<List<Integer>> pacificAtlantic(int[][] heights) {
            int n = heights.length;
            int m = heights[0].length;
            boolean[][] pacificVis = new boolean[n][m];
            for (int j = 0; j < m; j++) {
                dfs(0, j, pacificVis, heights);
            }
            for (int i = 1; i < n; i++) {
                dfs(i, 0, pacificVis, heights);
            }
            boolean[][] atlanticVis = new boolean[n][m];
            for (int j = 0; j < m; j++) {
                dfs(n - 1, j, atlanticVis, heights);
            }
            for (int i = 0; i < n - 1; i++) {
                dfs(i, m - 1, atlanticVis, heights);
            }
            List<List<Integer>> ans = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (pacificVis[i][j] && atlanticVis[i][j]) {
                        ans.add(List.of(i, j));
                    }
                }
            }
            return ans;
        }
        private void dfs(int i, int j, boolean[][] vis, int[][] heights) {
            if (vis[i][j]) {
                return;
            }
            vis[i][j] = true;
            for (int[] d : DIRS) {
                int x = i + d[0], y = j + d[1];
                if (0 <= x && x < heights.length && 0 <= y && y < heights[x].length && heights[x][y] >= heights[i][j]) { // 往高处走
                    dfs(x, y, vis, heights);
                }
            }
        }
    }*/

/*    class Solution {
        public int maxArea(int[] height) {
            int left = 0;
            int n = height.length;
            int right = n - 1;
            int ans = 0;
            while (left < right) {
                int h = Math.min(height[left], height[right]);
                ans = Math.max(ans, h * (right - left));
                while (left < right && height[left] <= h) {
                    left++;
                }
                while (left < right && height[right] <= h) {
                    right--;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int trapRainWater(int[][] heightMap) {
            int[] move = new int[] { -1, 0, 1, 0, -1 };
            int n = heightMap.length;
            int m = heightMap[0].length;
            PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
            boolean[][] visited = new boolean[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
                        visited[i][j] = true;
                        pq.add(new int[] { i, j, heightMap[i][j] });
                    } else {
                        visited[i][j] = false;
                    }
                }
            }
            int ans = 0;
            while (!pq.isEmpty()) {
                int[] record = pq.poll();
                int x = record[0];
                int y = record[1];
                int w = record[2];
                ans += w - heightMap[x][y];
                for (int i = 0, nx, ny, h; i < 4; i++) {
                    nx = x + move[i];
                    ny = y + move[i + 1];
                    if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
                        visited[nx][ny] = true;
                        pq.add(new int[] { nx, ny, Math.max(heightMap[nx][ny], w) });
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maxBottlesDrunk(int numBottles, int numExchange) {
            int ans = numBottles;
            while (numBottles >= numExchange) {
                numBottles -= numExchange - 1;
                ans++;
                numExchange++;
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int numWaterBottles(int numBottles, int numExchange) {
            int ans = numBottles;
            while (numBottles >= numExchange) {
                ans += numBottles / numExchange;
                numBottles = numBottles / numExchange + numBottles % numExchange;
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int triangularSum(int[] nums) {
            for (int n = nums.length - 1; n > 0; n--) {
                for (int i = 0; i < n; i++) {
                    nums[i] = (nums[i] + nums[i + 1]) % 10;
                }
            }
            return nums[0];
        }
    }*/

/*    class Solution {
        public int minScoreTriangulation(int[] values) {
            int n = values.length;
            int[][] dp = new int[n][n];
            for (int i = n - 3; i >= 0; i--) {
                for (int j = i + 2; j < n; j++) {
                    dp[i][j] = Integer.MAX_VALUE;
                    for (int k = i + 1; k < j; k++) {
                        dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j] + values[i] * values[k] * values[j]);
                    }
                }
            }
            return dp[0][n - 1];
        }
    }*/

/*    class Solution {
        public int largestPerimeter(int[] nums) {
            Arrays.sort(nums);
            for (int i = nums.length - 1; i >= 2; i--) {
                if (nums[i - 2] + nums[i - 1] > nums[i]) {
                    return nums[i - 2] + nums[i - 1] + nums[i];
                }
            }
            return 0;
        }
    }*/


/*    class Solution {
        public double largestTriangleArea(int[][] points) {
            int n = points.length;
            double res = 0;
            for (int i = 0; i < n - 2; i++) {
                for (int j = i + 1; j < n - 1; j++) {
                    for (int k = j + 1; k < n; k++) {
                        int x1 = points[i][0], y1 = points[i][1];
                        int x2 = points[j][0], y2 = points[j][1];
                        int x3 = points[k][0], y3 = points[k][1];
                        res = Math.max(res, 0.5 * Math.abs((x1 * y2 + x2 * y3 + x3 * y1) - (x2 * y1 + x3 * y2 + x1 * y3)));
//                        res = Math.max(res, 0.5 * Math.abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)));
                    }
                }
            }
            return res;
        }
    }*/

/*    class Solution {
        public int triangleNumber(int[] nums) {
            Arrays.sort(nums);
            int ans = 0;
            for (int k = 2; k < nums.length; k++) {
                int c = nums[k];
                int i = 0;
                int j = k - 1;
                while (i < j) {
                    if (nums[i] + nums[j] > c) {
                        ans += j - i;
                        j--;
                    } else {
                        i++;
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int minimumTotal(List<List<Integer>> triangle) {
            int n = triangle.size();
            int[][] dp = new int[n][n];
            int[][] target = new int[n][n];
            for (int i = 0; i < triangle.size(); i++) {
                List<Integer> list = triangle.get(i);
                int index = 0;
                for (Integer x : list) {
                    target[i][index++] = x;
                }
            }
            dp[0][0] = target[0][0];
            for (int i = 1; i < n; i++) {
                dp[i][0] = dp[i - 1][0] + target[i][0];
            }
            for (int i = 1; i < n; i++) {
                for (int j = 1; j <= i; j++) {
                    if (j == i) {
                        dp[i][j] = dp[i - 1][j - 1] + target[i][j];
                    } else {
                        dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1]) + target[i][j];
                    }
                }
            }
            int value = 999;
            for (int j = 0; j < n; j++) {
                value = Math.min(value, dp[n - 1][j]);
            }
            return value;
        }
    }*/

/*    class Solution {
        public String fractionToDecimal(int numerator, int denominator) {
            long a = numerator;
            long b = denominator;
            if (a % b == 0) {
                return String.valueOf(a / b);
            }
            StringBuilder sb = new StringBuilder();
            if (a * b < 0) {
                sb.append('-');
            }
            a = Math.abs(a);
            b = Math.abs(b);
            sb.append(a / b + ".");
            a %= b;
            Map<Long, Integer> map = new HashMap<>();
            while (a != 0) {
                map.put(a, sb.length());
                a *= 10;
                sb.append(a / b);
                a %= b;
                if (map.containsKey(a)) {
                    int u = map.get(a);
                    return String.format("%s(%s)", sb.substring(0, u), sb.substring(u));
                }
            }
            return sb.toString();
        }
    }*/

/*    class Solution {
        public int compareVersion(String version1, String version2) {
            String[] ver1Arr = version1.split("\\.");
            String[] ver2Arr = version2.split("\\.");
            int n = ver1Arr.length;
            int m = ver2Arr.length;
            for (int i = 0; i < n || i < m; i++) {
                int a = i < n ? Integer.parseInt(ver1Arr[i]) : 0;
                int b = i < m ? Integer.parseInt(ver2Arr[i]) : 0;
                if (a != b) {
                    return a < b ? -1 : 1;
                }

            }
            return 0;
        }
    }*/

/*    class Solution {
        public int maxFrequencyElements(int[] nums) {
            int cnt = 0;
            int[] map = new int[101];
            int ans = 0;
            for (int x : nums) {
                map[x]++;
                if (map[x] > cnt) {
                    cnt = map[x];
                    ans = cnt;
                } else if (map[x] == cnt) {
                    ans += cnt;
                }
            }
            return ans;
        }
    }*/

/*    class MovieRentingSystem {
        // (shop, movie) -> price
        private final Map<Long, Integer> shopMovieToPrice = new HashMap<>();

        // movie -> {(price, shop)}
        private final Map<Integer, TreeSet<int[]>> unrentedMovieToPriceShop = new HashMap<>();

        // {(price, shop, movie)}
        private final TreeSet<int[]> rentedMovies = new TreeSet<>((a, b) -> {
            if (a[0] != b[0]) {
                return a[0] - b[0];
            }
            if (a[1] != b[1]) {
                return a[1] - b[1];
            }
            return a[2] - b[2];
        });

        public MovieRentingSystem(int n, int[][] entries) {
            for (int[] e : entries) {
                int shop = e[0], movie = e[1], price = e[2];
                // 把 shop 和 movie 存储到一个 long 中，方便作为 HashMap 的 key
                shopMovieToPrice.put((long) shop << 32 | movie, price);
                unrentedMovieToPriceShop
                        .computeIfAbsent(movie, _ -> new TreeSet<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]))
                        .add(new int[]{price, shop});
            }
        }

        // 获取 unrentedMovieToPriceShop[movie] 的前 5 个 shop
        public List<Integer> search(int movie) {
            if (!unrentedMovieToPriceShop.containsKey(movie)) {
                return List.of();
            }
            List<Integer> ans = new ArrayList<>(5); // 预分配空间
            for (int[] ps : unrentedMovieToPriceShop.get(movie)) {
                ans.add(ps[1]);
                if (ans.size() == 5) {
                    break;
                }
            }
            return ans;
        }

        // 借电影
        public void rent(int shop, int movie) {
            int price = shopMovieToPrice.get((long) shop << 32 | movie);
            // 从 unrentedMovieToPriceShop 移到 rentedMovies
            unrentedMovieToPriceShop.get(movie).remove(new int[]{price, shop});
            rentedMovies.add(new int[]{price, shop, movie});
        }

        // 还电影
        public void drop(int shop, int movie) {
            int price = shopMovieToPrice.get((long) shop << 32 | movie);
            // 从 rentedMovies 移到 unrentedMovieToPriceShop
            rentedMovies.remove(new int[]{price, shop, movie});
            unrentedMovieToPriceShop.get(movie).add(new int[]{price, shop});
        }

        // 获取 rentedMovies 的前 5 个 shop 和 movie
        public List<List<Integer>> report() {
            List<List<Integer>> ans = new ArrayList<>(5); // 预分配空间
            for (int[] e : rentedMovies) {
                ans.add(List.of(e[1], e[2]));
                if (ans.size() == 5) {
                    break;
                }
            }
            return ans;
        }
    }*/

/*    public class Router {
        public int memoryLimit;
        public Queue<Packet> queue = new LinkedList<>();
        public Set<Key> keySet = new HashSet<>();
        public Map<Integer, DestinationInfo> destinationMap = new HashMap<>();

        public Router(int memoryLimit) {
            this.memoryLimit = memoryLimit;
        }

        public boolean addPacket(int source, int destination, int timestamp) {
            Key key = new Key(source, destination, timestamp);
            if (keySet.contains(key)) {
                return false;
            }

            if (queue.size() == memoryLimit) {
                Packet oldest = queue.poll();
                Key oldestKey = new Key(oldest.source, oldest.destination, oldest.timestamp);
                keySet.remove(oldestKey);
                DestinationInfo di = destinationMap.get(oldest.destination);
                if (di != null) {
                    di.start++;
                }
            }

            Packet newPacket = new Packet(source, destination, timestamp);
            queue.offer(newPacket);
            keySet.add(key);

            DestinationInfo di = destinationMap.computeIfAbsent(destination, k -> new DestinationInfo());
            di.timestamps.add(timestamp);

            return true;
        }

        public int[] forwardPacket() {
            if (queue.isEmpty()) {
                return new int[0];
            }

            Packet packet = queue.poll();
            Key key = new Key(packet.source, packet.destination, packet.timestamp);
            keySet.remove(key);

            DestinationInfo di = destinationMap.get(packet.destination);
            if (di != null) {
                di.start++;
            }

            return new int[] { packet.source, packet.destination, packet.timestamp };
        }

        public int getCount(int destination, int startTime, int endTime) {
            DestinationInfo di = destinationMap.get(destination);
            if (di == null) {
                return 0;
            }

            int size = di.timestamps.size();
            int startIdx = di.start;

            if (startIdx >= size) {
                return 0;
            }

            int left = lowerBound(di.timestamps, startIdx, size - 1, startTime);
            int rightUpper = upperBound(di.timestamps, startIdx, size - 1, endTime);
            int right = rightUpper - 1;

            if (left > right) {
                return 0;
            }

            return right - left + 1;
        }

        private int lowerBound(List<Integer> list, int from, int to, int target) {
            int low = from;
            int high = to + 1;

            while (low < high) {
                int mid = (low + high) / 2;
                if (list.get(mid) < target) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }

            return low;
        }

        private int upperBound(List<Integer> list, int from, int to, int target) {
            int low = from;
            int high = to + 1;
            while (low < high) {
                int mid = (low + high) / 2;
                if (list.get(mid) <= target) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }

            return low;
        }
    }

    class Packet {
        int source;
        int destination;
        int timestamp;

        public Packet(int source, int destination, int timestamp) {
            this.source = source;
            this.destination = destination;
            this.timestamp = timestamp;
        }
    }

    class Key {
        int source;
        int destination;
        int timestamp;

        public Key(int source, int destination, int timestamp) {
            this.source = source;
            this.destination = destination;
            this.timestamp = timestamp;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Key key = (Key) o;
            return source == key.source &&
                    destination == key.destination &&
                    timestamp == key.timestamp;
        }

        @Override
        public int hashCode() {
            return Objects.hash(source, destination, timestamp);
        }
    }

    class DestinationInfo {
        List<Integer> timestamps = new ArrayList<>();
        int start = 0;
    }*/

/*    class Spreadsheet {
        private final Map<String, Integer> data = new HashMap<>();

        public Spreadsheet(int rows) {
        }

        public void setCell(String cell, int value) {
            data.put(cell, value);
        }

        public void resetCell(String cell) {
            data.remove(cell);
        }

        public int getValue(String formula) {
            int ans = 0;
            for (String cell : formula.substring(1).split("\\+")) {
                if (Character.isUpperCase(cell.charAt(0))) {
                    ans += data.getOrDefault(cell, 0);
                } else {
                    ans += Integer.parseInt(cell);
                }
            }
            return ans;
        }
    }*/

/*    class TaskManager {
        private final Map<Integer, int[]> mp = new HashMap<>();

        private final PriorityQueue<int[]> pq =
                new PriorityQueue<>((a, b) -> a[0] != b[0] ? b[0] - a[0] : b[1] - a[1]);

        public TaskManager(List<List<Integer>> tasks) {
            for (List<Integer> task : tasks) {
                add(task.get(0), task.get(1), task.get(2));
            }
        }

        public void add(int userId, int taskId, int priority) {
            mp.put(taskId, new int[]{priority, userId});
            pq.offer(new int[]{priority, taskId, userId});
        }

        public void edit(int taskId, int newPriority) {
            int userId = mp.get(taskId)[1];
            add(userId, taskId, newPriority);
        }

        public void rmv(int taskId) {
            mp.get(taskId)[0] = -1;
        }

        public int execTop() {
            while (!pq.isEmpty()) {
                int[] top = pq.poll();
                int priority = top[0], taskId = top[1], userId = top[2];
                int[] p = mp.get(taskId);
                if (p[0] == priority && p[1] == userId) {
                    rmv(taskId);
                    return userId;
                }
            }
            return -1;
        }
    }*/

/*    class NumberContainers {
        private final Map<Integer, Integer> indexToNumber = new HashMap<>();
        private final Map<Integer, PriorityQueue<Integer>> numberToIndices = new HashMap<>();

        public void change(int index, int number) {
            indexToNumber.put(index, number);
            numberToIndices.computeIfAbsent(number, _ -> new PriorityQueue<>()).offer(index);
        }

        public int find(int number) {
            PriorityQueue<Integer> indices = numberToIndices.get(number);
            if (indices == null) {
                return -1;
            }
            while (!indices.isEmpty() && indexToNumber.get(indices.peek()) != number) {
                indices.poll();
            }
            return indices.isEmpty() ? -1 : indices.peek();
        }
    }*/

/*    class Solution {
        public List<Integer> replaceNonCoprimes(int[] nums) {
            List<Integer> st = new ArrayList<>();
            for (int x : nums) {
                while (!st.isEmpty() && gcd(x, st.getLast()) > 1) {
                    x = lcm(x, st.removeLast());
                }
                st.add(x);
            }
            return st;
        }

        private int gcd(int a, int b) {
            while (a != 0) {
                int tmp = a;
                a = b % a;
                b = tmp;
            }
            return b;
        }

        private int lcm(int a, int b) {
            return a / gcd(a, b) * b;
        }
    }*/

/*    class Solution {
        public int canBeTypedWords(String text, String brokenLetters) {
            String[] wordArr = text.split(" ");
            int ans = 0;
            for (String word : wordArr) {
                boolean flag = true;
                for (char ch : brokenLetters.toCharArray()) {
                    if (word.indexOf(ch) != -1) {
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    ans++;
                }
            }
            return ans;
        }
    }*/

    /*class Solution {
        public String[] spellchecker(String[] wordlist, String[] queries) {
            int n = wordlist.length;
            Set<String> origin = new HashSet<>(Arrays.asList(wordlist));
            Map<String, String> lowerToOrigin = new HashMap<>(n);
            Map<String, String> vowelToOrigin = new HashMap<>(n);

            for (int i = n - 1; i >= 0; i--) {
                String s = wordlist[i];
                String lower = s.toLowerCase();
                lowerToOrigin.put(lower, s);
                vowelToOrigin.put(replaceVowels(lower), s);
            }

            for (int i = 0; i < queries.length; i++) {
                String q = queries[i];
                if (origin.contains(q)) {
                    continue;
                }
                String lower = q.toLowerCase();
                if (lowerToOrigin.containsKey(lower)) {
                    queries[i] = lowerToOrigin.get(lower);
                } else { // 不区分大小写+元音模糊匹配
                    queries[i] = vowelToOrigin.getOrDefault(replaceVowels(lower), "");
                }
            }
            return queries;
        }

        private String replaceVowels(String str) {
            char[] s = str.toCharArray();
            for (int i = 0; i < s.length; ++i) {
                char c = s[i];
                if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
                    s[i] = '?';
                }
            }
            return new String(s);
        }
    }*/

    /*class Solution {
        public int maxFreqSum(String s) {
            int[] cnt = new int[26];
            int yuan = 0;
            int fu = 0;
            for (char ch : s.toCharArray()) {
                cnt[ch - 'a']++;
                if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
                    yuan = Math.max(yuan, cnt[ch - 'a']);
                } else {
                    fu = Math.max(fu, cnt[ch - 'a']);
                }
            }
            return yuan + fu;
        }
    }*/

/*    class Solution {
        public boolean doesAliceWin(String s) {
            for (char c : s.toCharArray()) {
                if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
                    return true;
                }
            }
            return false;
        }
    }*/

/*    class Solution {
        public String sortVowels(String s) {
            char[] sArr = s.toCharArray();
            int n = sArr.length;
            LinkedList<Character> list = new LinkedList<>();
            for (int i = 0; i < n; i++) {
                if (isFlag(sArr[i])) {
                    list.addLast(sArr[i]);
                    sArr[i] = '.';
                }
            }
            Collections.sort(list);
            for (int i = 0; i < n; i++) {
                if (sArr[i] == '.') {
                    sArr[i] = list.getFirst();
                    list.removeFirst();
                }
            }
            return new String(sArr);
        }

        private Boolean isFlag(char c){
            c = Character.toLowerCase(c);
            return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
        }
    }*/

/*    class Solution {

        private int total = 0;

        public int minimumTeachings(int n, int[][] languages, int[][] friendships) {
            int m = languages.length;
            boolean[][] learned = new boolean[m][n + 1];
            for (int i = 0; i < m; i++) {
                for (int x : languages[i]) {
                    learned[i][x] = true;
                }
            }
            boolean[] vis = new boolean[m];
            int[] cnt = new int[n + 1];
            next: for (int[] f : friendships) {
                int u = f[0] - 1;
                int v = f[1] - 1;
                for (int x : languages[u]) {
                    if (learned[v][x]) {
                        continue next;
                    }
                }
                add(u, languages, vis, cnt);
                add(v, languages, vis, cnt);
            }

            int maxCnt = 0;
            for (int c : cnt) {
                maxCnt = Math.max(maxCnt, c);
            }

            return total - maxCnt;
        }

        private int add(int u, int[][] languages, boolean[] vis, int[] cnt) {
            if (vis[u]) {
                return total;
            }
            vis[u] = true;
            total++;
            for (int x : languages[u]) {
                cnt[x]++;
            }
            return total;
        }
    }*/

/*    class Solution {
        public static final int MOD = 1_000_000_007;

        public int peopleAwareOfSecret(int n, int delay, int forget) {
            int[] known = new int[n + 1];
            known[1] = 1;
            long ans = 0;
            for (int i = 1; i <= n; i++) {
                if (i >= n - forget + 1) {
                    ans += known[i];
                }
                for (int j = i + delay; j <= Math.min(i + forget - 1, n); j++) {
                    known[j] = (known[j] + known[i]) % MOD;
                }
            }
            return (int) (ans % MOD);
        }
    }*/

/*    class Solution {
        public int[] getNoZeroIntegers(int n) {
            for (int i = 1; i < n; i++) {
                if (!Integer.toString(i).contains("0") &&
                        !Integer.toString(n - i).contains("0")) {
                    return new int[] { i, n - i };
                }
            }
            return new int[] {-1,-1};
        }
    }*/

/*    class Solution {
        public int[] sumZero(int n) {
            int[] ans = new int[n];
            for (int i = 0; i < n - 1; i++) {
                ans[i] = i + 1;
            }
            int x = (1 + n - 1) * (n - 1) / 2;
            ans[n - 1] = -x;
            return ans;
        }
    }*/

/*    class Solution {
        public long minOperations(int[][] queries) {
            long ans = 0;
            for (int[] q : queries) {
                ans += (f(q[1]) - f(q[0] - 1) + 1) / 2;
            }
            return ans;
        }

        private long f(int n) {
            int m = 32 - Integer.numberOfLeadingZeros(n);
            long res = 0;
            for (int i = 1; i < m; i++) {
                res += (long) (i + 1) / 2 << (i - 1);
            }
            return res + (long) (m + 1) / 2 * (n + 1 - (1 << m >> 1));
        }
    }*/

/*    class Solution {
        public int makeTheIntegerZero(int num1, int num2) {
            for (long k = 1; k <= num1 - num2 * k; k++) {
                if (k >= Long.bitCount(num1 - num2 * k)) {
                    return (int) k;
                }
            }
            return -1;
        }
    }*/

/*    class Solution {
        public int findClosest(int x, int y, int z) {
            return Math.abs(x - z) < Math.abs(y - z) ? 1 : Math.abs(x - z) > Math.abs(y - z) ? 2 : 0;
        }
    }*/

/*    class Solution {
        public int numberOfPairs(int[][] points) {
            Arrays.sort(points, (a, b) -> a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]);
            int ans = 0;
            for (int i = 0; i < points.length; i++) {
                int y1 = points[i][1];
                int maxY = Integer.MIN_VALUE;
                for (int j = i + 1; j < points.length; j++) {
                    int y2 = points[j][1];
                    if (y2 <= y1 && y2 > maxY) {
                        maxY = y2;
                        ans++;
                    }
                }
            }
            return ans;
        }
    }*/

//    class Solution {
//        public int numberOfPairs(int[][] points) {
//            Arrays.sort(points, (a, b) -> a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]);
//            int ans = 0;
//            for (int i = 0; i < points.length; i++) {
//                int y1 = points[i][1];
//                int maxY = Integer.MIN_VALUE;
//                for (int j = i + 1; j < points.length; j++) {
//                    int y2 = points[j][1];
//                    if (y2 <= y1 && y2 > maxY) {
//                        maxY = y2;
//                        ans++;
//                    }
//                }
//            }
//            return ans;
//        }
//    }


/*    class Solution {
        public double maxAverageRatio(int[][] classes, int extraStudents) {
            record Node(double gain, int a, int b) {}
            PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> Double.compare(b.gain, a.gain));

            for (int[] c : classes) {
                int a = c[0];
                int b = c[1];
                double gain = 1.0 * (b - a) / (1L * b * (b + 1));
                pq.add(new Node(gain, a, b));
            }

            while (extraStudents-- > 0) {
                Node top = pq.poll();
                int a = top.a + 1;
                int b = top.b + 1;
                double gain = 1.0 * (b - a) / (1L * b * (b + 1));
                pq.add(new Node(gain, a, b));
            }

            double sum = 0;
            int n = pq.size();
            while (!pq.isEmpty()) {
                Node top = pq.poll();
                sum += 1.0 * top.a / top.b;
            }
            return sum / n;
        }
    }*/

/*    class Solution {
        public void solveSudoku(char[][] board) {
            solveSudokuHelper(board);
        }
        private boolean solveSudokuHelper(char[][] board) {
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++) {
                    if (board[i][j] != '.') {
                        continue;
                    }
                    for (char k = '1'; k <= '9'; k++) {
                        if (isValidSudoku(i, j, k, board)) {
                            board[i][j] = k;
                            if (solveSudokuHelper(board)) {
                                return true;
                            }
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
            return true;
        }
        private boolean isValidSudoku(int row, int col, char val, char[][] board) {
            for (int i = 0; i < 9; i++) {
                if (board[row][i] == val) {
                    return false;
                }
            }
            for (int j = 0; j < 9; j++) {
                if (board[j][col] == val) {
                    return false;
                }
            }
            int startRow = (row / 3) * 3;
            int startCol = (col / 3) * 3;
            for (int i = startRow; i < startRow + 3; i++) {
                for (int j = startCol; j < startCol + 3; j++) {
                    if (board[i][j] == val) {
                        return false;
                    }
                }
            }
            return true;
        }
    }*/

/*    class Solution {
        public boolean isValidSudoku(char[][] board) {
            boolean[][] rowHas = new boolean[9][9];
            boolean[][] colHas = new boolean[9][9];
            boolean[][][] subBoxHas = new boolean[3][3][9];
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++) {
                    char b = board[i][j];
                    if (b == '.') {
                        continue;
                    }
                    int x = b - '1';
                    if (rowHas[i][x] || colHas[j][x] || subBoxHas[i / 3][j / 3][x]) {
                        return false;
                    }
                    rowHas[i][x] = colHas[j][x] = subBoxHas[i / 3][j / 3][x] = true;
                }
            }
            return true;
        }
    }*/

/*    class Solution {
        public long flowerGame(int n, int m) {
            return (long) n * m / 2;
        }
    }*/

/*    class Solution {
        public int[][] sortMatrix(int[][] grid) {
            int m = grid.length;
            int n = grid[0].length;
            for (int k = 1; k < m + n; k++) {
                int minJ = Math.max(n - k, 0);
                int maxJ = Math.min(m + n - 1 - k, n - 1);
                List<Integer> a = new ArrayList<>(maxJ - minJ + 1);
                for (int j = minJ; j <= maxJ; j++) {
                    a.add(grid[k + j - n][j]);
                }
                a.sort(minJ > 0 ? null : Comparator.reverseOrder());
                for (int j = minJ; j <= maxJ; j++) {
                    grid[k + j - n][j] = a.get(j - minJ);
                }
            }
            return grid;
        }
    }*/

/*    class Solution {
        private static final int[][] DIRS = {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};

        public int lenOfVDiagonal(int[][] grid) {
            int m = grid.length;
            int n = grid[0].length;
            int[][][] memo = new int[m][n][1 << 3];
            int ans = 0;
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    if (grid[i][j] == 1) {
                        for (int k = 0; k < 4; k++) {
                            ans = Math.max(ans, dfs(i, j, k, 1, 2, grid, memo) + 1);
                        }
                    }
                }
            }
            return ans;
        }
        private int dfs(int i, int j, int k, int canTurn, int target, int[][] grid, int[][][] memo) {
            i += DIRS[k][0];
            j += DIRS[k][1];
            if (i < 0 || i >= grid.length || j < 0 || j >= grid[i].length || grid[i][j] != target) {
                return 0;
            }
            int mask = k << 1 | canTurn;
            if (memo[i][j][mask] > 0) {
                return memo[i][j][mask];
            }
            int res = dfs(i, j, k, canTurn, 2 - target, grid, memo) + 1;
            if (canTurn == 1) {
                res = Math.max(res, dfs(i, j, (k + 1) % 4, 0, 2 - target, grid, memo) + 1);
            }
            return memo[i][j][mask] = res;
        }
    }*/

/*    class Solution {
        public int areaOfMaxDiagonal(int[][] dimensions) {
            int offset = 0;
            int ans = 0;
            for (int i = 0; i < dimensions.length; i++) {
                int[] x = dimensions[i];
                int tmp = x[0] * x[0] + x[1] * x[1];
                if (tmp >= offset) {
                    if (tmp > offset) {
                        ans = x[0] * x[1];
                    } else {
                        ans = Math.max(ans, x[0] * x[1]);
                    }
                    offset = tmp;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int[] findDiagonalOrder(int[][] mat) {
            int m = mat.length;
            int n = mat[0].length;
            int[] ans = new int[m * n];
            int idx = 0;
            for (int k = 0; k < m + n - 1; k++) {
                int minJ = Math.max(k - m + 1, 0);
                int maxJ = Math.min(k, n - 1);
                if (k % 2 == 0) {
                    for (int j = minJ; j <= maxJ; j++) {
                        ans[idx++] = mat[k - j][j];
                    }
                } else {
                    for (int j = maxJ; j >= minJ; j--) {
                        ans[idx++] = mat[k - j][j];
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int longestSubarray(int[] nums) {
            int l = 0;
            int r = 0;
            int res = 0;
            boolean flag = false;
            while(r < nums.length){
                while(flag && nums[r] == 0){
                    if(nums[l] == 0){
                        flag = false;
                    }
                    l++;
                }
                if(nums[r] == 0){
                    flag = true;
                }
                res = Math.max(res, r-l);
                r++;
            }
            return res;
        }
    }*/

/*    class Solution {
        public int minimumSum(int[][] grid) {
            return Math.min(solve(grid), solve(rotate(grid)));
        }

        private int solve(int[][] a) {
            int m = a.length;
            int n = a[0].length;
            int ans = Integer.MAX_VALUE;

            if (m >= 3) {
                for (int i = 1; i < m; i++) {
                    for (int j = i + 1; j < m; j++) {
                        int area = minimumArea(a, 0, i, 0, n);
                        area += minimumArea(a, i, j, 0, n);
                        area += minimumArea(a, j, m, 0, n);
                        ans = Math.min(ans, area);
                    }
                }
            }

            if (m >= 2 && n >= 2) {
                for (int i = 1; i < m; i++) {
                    for (int j = 1; j < n; j++) {
                        int area = minimumArea(a, 0, i, 0, n);
                        area += minimumArea(a, i, m, 0, j);
                        area += minimumArea(a, i, m, j, n);
                        ans = Math.min(ans, area);
                        area = minimumArea(a, 0, i, 0, j);
                        area += minimumArea(a, 0, i, j, n);
                        area += minimumArea(a, i, m, 0, n);
                        ans = Math.min(ans, area);
                    }
                }
            }

            return ans;
        }

        private int minimumArea(int[][] a, int u, int d, int l, int r) {
            int left = r;
            int right = 0;
            int top = d;
            int bottom = 0;
            for (int i = u; i < d; i++) {
                for (int j = l; j < r; j++) {
                    if (a[i][j] == 1) {
                        left = Math.min(left, j);
                        right = Math.max(right, j);
                        top = Math.min(top, i);
                        bottom = i;
                    }
                }
            }
            return (right - left + 1) * (bottom - top + 1);
        }

        private int[][] rotate(int[][] a) {
            int m = a.length;
            int n = a[0].length;
            int[][] b = new int[n][m];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    b[j][m - 1 - i] = a[i][j];
                }
            }
            return b;
        }
    }*/

/*    class Solution {
        public int minimumArea(int[][] grid) {
            int left = grid[0].length;
            int right = 0;
            int top = grid.length;
            int bottom = 0;
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[i].length; j++) {
                    if (grid[i][j] == 1) {
                        left = Math.min(left, j);
                        right = Math.max(right, j);
                        top = Math.min(top, i);
                        bottom = i;
                    }
                }
            }
            return (right - left + 1) * (bottom - top + 1);
        }
    }*/

/*    class Solution {
        public int MAX_N = 151;

        public int[] stack = new int[MAX_N];

        public int[] heights = new int[MAX_N];

        public int size;

        public int numSubmat(int[][] mat) {
            int n = mat.length;
            int m = mat[0].length;
            Arrays.fill(heights, 0, m, 0);
            int ans = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    heights[j] = mat[i][j] == 0 ? 0 : heights[j] + 1;
                }
                ans += countFromBottom(m);
            }
            return ans;
        }

        public int countFromBottom(int m) {
            int ans = 0;
            for (int i = 0; i < m; i++) {
                while (size > 0 && heights[stack[size - 1]] >= heights[i]) {
                    int cur = stack[--size];
                    if (heights[cur] > heights[i]) {
                        int left = size == 0 ? -1 : stack[size - 1];
                        int len = i - left - 1;
                        int bottom = Math.max(left == -1 ? 0 : heights[left], heights[i]);
                        ans += (heights[cur] - bottom) * len * (len + 1) / 2;
                    }
                }
                stack[size++] = i;
            }
            while (size > 0) {
                int cur = stack[--size];
                int left = size == 0 ? -1 : stack[size - 1];
                int len = m - left - 1;
                int bottom = left == -1 ? 0 : heights[left];
                ans += (heights[cur] - bottom) * len * (len + 1) / 2;
            }
            return ans;
        }
    }*/

    /*class Solution {
        public int countSquares(int[][] matrix) {
            int n = matrix.length;
            int m = matrix[0].length;
            int[][] dp = new int[n + 1][m + 1];
            int ans = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (matrix[i][j] > 0) {
                        dp[i + 1][j + 1] = Math.min(Math.min(dp[i][j], dp[i][j + 1]), dp[i + 1][j]) + 1;
                        ans += dp[i + 1][j + 1];
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public long zeroFilledSubarray(int[] nums) {
            long cnt = 0;
            long ans = 0;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] == 0) {
                    cnt++;
                } else {
                    ans += (1 + cnt) * cnt / 2;
                    cnt = 0;
                }
            }
            ans += (1 + cnt) * cnt / 2;
            return ans;
        }
    }*/

/*    class Solution {
        private static final double EPS = 1e-9;

        public boolean judgePoint24(int[] cards) {
            List<Double> a = new ArrayList<>();
            for (int x : cards) {
                a.add((double) x);
            }
            return dfs(a);
        }

        private boolean dfs(List<Double> cards) {
            int n = cards.size();
            if (n == 1) {
                return Math.abs(cards.get(0) - 24) < EPS;
            }
            for (int i = 0; i < n; i++) {
                double x = cards.get(i);
                for (int j = i + 1; j < n; j++) {
                    double y = cards.get(j);
                    List<Double> candidates = new ArrayList<>();
                    candidates.add(x + y);
                    candidates.add(x - y);
                    candidates.add(y - x);
                    candidates.add(x * y);
                    if (Math.abs(y) > EPS) {
                        candidates.add(x / y);
                    }
                    if (Math.abs(x) > EPS) {
                        candidates.add(y / x);
                    }
                    List<Double> newCards = new ArrayList<>(cards);
                    newCards.remove(j);
                    for (double res : candidates) {
                        newCards.set(i, res);
                        if (dfs(newCards)) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    }*/

/*    class Solution {
        public double new21Game(int n, int k, int maxPts) {
            double[] dp = new double[n + 1];
            double s = 0;
            for (int i = n; i >= 0; i--) {
                dp[i] = i >= k ? 1 : s / maxPts;
                s += dp[i];
                if (i + maxPts <= n) {
                    s -= dp[i + maxPts];
                }
            }
            return dp[0];
        }
    }*/

/*    class Solution {
        public int maximum69Number(int num) {
            char[] strArr = String.valueOf(num).toCharArray();
            for (int i = 0; i < strArr.length; i++) {
                if (strArr[i] == '6') {
                    strArr[i] = '9';
                    break;
                }
            }
            return Integer.valueOf(new String(strArr));
        }
    }*/

/*    class Solution {
        public boolean isPowerOfFour(int n) {
            if (n <= 0) {
                return false;
            }
            if (n == 1) {
                return true;
            }
            while (n != 4) {
                if (n % 4 != 0) {
                    return false;
                }
                n /= 4;
            }
            return true;
        }
    }*/

/*    class Solution {
        public boolean checkPowersOfThree(int n) {
            while (n > 0) {
                if (n % 3 == 2) {
                    return false;
                }
                n /= 3;
            }
            return true;
        }
    }*/

/*    class Solution {
        public boolean isPowerOfThree(int n) {
            return n > 0 && 1162261467 % n == 0;
        }
    }*/

/*    class Solution {
        public static final int MOD = 1_000_000_007;
         int numberOfWays(int n, int x) {
            long[] dp = new long[n + 1];
            dp[0] = 1;
            for (int i = 1; Math.pow(i, x) <= n; i++) {
                int v = (int) Math.pow(i, x);
                for (int s = n; s >= v; s--) {
                    dp[s] += dp[s - v];
                }
            }
            return (int) (dp[n] % MOD);
        }
    }*/

   /* class Solution {

        public static final int  MOD = 1_000_000_007;
        public int[] productQueries(int n, int[][] queries) {
            List<Integer> powers = new ArrayList<>();
            while (n > 0) {
                int lowbit = n & -n;
                powers.add(lowbit);
                n ^= lowbit;
            }
            int[] ans = new int[queries.length];
            for (int i = 0; i < queries.length; i++) {
                int[] q = queries[i];
                long mul = 1;
                for (int j = q[0]; j <= q[1]; j++) {
                    mul = mul * powers.get(j) % MOD;
                }
                ans[i] = (int) mul;
            }
            return ans;
        }
    }*/

/*    class Solution {
        private static final Set<String> st = new HashSet<>();

        static {
            final int MAX_N = 1_000_000_000;
            for (int i = 1; i < MAX_N; i <<= 1) {
                String s = intToSortedStr(i);
                st.add(s);
            }
        }

        private static String intToSortedStr(int n) {
            char[] s = String.valueOf(n).toCharArray();
            Arrays.sort(s);
            return new String(s);
        }

        public boolean reorderedPowerOf2(int n) {
            String s = intToSortedStr(n);
            return st.contains(s);
        }
    }*/

/*    class Solution {
        public boolean isPowerOfTwo(int n) {
            return n > 0 && n == (n & (-n));
        }
    }*/

/*    class Solution {
        public double soupServings(int n) {
            if (n >= 4451) {
                return 1;
            }

            n = (n + 24) / 25;
            double[][] dp = new double[n + 1][n + 1];
            return dfs(n, n, dp);
        }

        private double dfs(int a, int b, double[][] dp) {
            if (a <= 0 && b <= 0) {
                return 0.5;
            }
            if (a <= 0) {
                return 1;
            }
            if (b <= 0) {
                return 0;
            }
            if (dp[a][b] == 0) {
                dp[a][b] = (dfs(a - 4, b, dp) + dfs(a - 3, b - 1, dp) + dfs(a - 2, b - 2, dp) + dfs(a - 1, b - 3, dp)) / 4;
            }
            return dp[a][b];
        }
    }*/

    /*class Solution {
        public int maxCollectedFruits(int[][] fruits) {
            int n = fruits.length;
            int[][] dp = new int[n][n];
            for (int[] row : dp) {
                Arrays.fill(row, -1);
            }

            int ans = 0;
            for (int i = 0; i < n; i++) {
                ans += fruits[i][i];
            }
            ans += dfs(n - 2, n - 1, fruits, dp);
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < i; j++) {
                    fruits[j][i] = fruits[i][j];
                }
            }
            for (int[] row : dp) {
                Arrays.fill(row, -1);
            }
            return ans + dfs(n - 2, n - 1, fruits, dp);
        }

        private int dfs(int i, int j, int[][] fruits, int[][] dp) {
            int n = fruits.length;
            if (j < n - 1 - i || j >= n) {
                return 0;
            }
            if (i == 0) {
                return fruits[i][j];
            }
            if (dp[i][j] != -1) {
                return dp[i][j];
            }
            int res1 = dfs(i - 1, j - 1, fruits, dp);
            int res2 = dfs(i - 1, j, fruits, dp);
            int res3 = dfs(i - 1, j + 1, fruits, dp);
            int res = Math.max(Math.max(res1, res2), res3) + fruits[i][j];
            return dp[i][j] = res;
        }
    }*/

/*    class SegmentTree {
        private final int[] max;

        public SegmentTree(int[] a) {
            int n = a.length;
            max = new int[2 << (32 - Integer.numberOfLeadingZeros(n - 1))];
            build(a, 1, 0, n - 1);
        }

        public int findFirstAndUpdate(int o, int l, int r, int x) {
            if (max[o] < x) {
                return -1;
            }
            if (l == r) {
                max[o] = -1;
                return l;
            }
            int m = (l + r) / 2;
            int i = findFirstAndUpdate(o * 2, l, m, x);
            if (i < 0) {
                i = findFirstAndUpdate(o * 2 + 1, m + 1, r, x);
            }
            maintain(o);
            return i;
        }

        private void maintain(int o) {
            max[o] = Math.max(max[o * 2], max[o * 2 + 1]);
        }

        private void build(int[] a, int o, int l, int r) {
            if (l == r) {
                max[o] = a[l];
                return;
            }
            int m = (l + r) / 2;
            build(a, o * 2, l, m);
            build(a, o * 2 + 1, m + 1, r);
            maintain(o);
        }
    }

    class Solution {
        public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
            SegmentTree t = new SegmentTree(baskets);
            int n = baskets.length;
            int ans = 0;
            for (int x : fruits) {
                if (t.findFirstAndUpdate(1, 0, n - 1, x) < 0) {
                    ans++;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
            int ans = fruits.length;
            int n = fruits.length;
            boolean[] flag = new boolean[n];
            for (int x : fruits) {
                for (int i = 0; i < n; i++) {
                    if (flag[i]) {
                        continue;
                    }
                    if (baskets[i] >= x) {
                        ans--;
                        flag[i] = true;
                        break;
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int totalFruit(int[] fruits) {
            int n = fruits.length;
            HashMap<Integer, Integer> map = new HashMap<>();
            int left = 0;
            int ans = 0;
            for (int right = 0; right < n; right++) {
                map.put(fruits[right], map.getOrDefault(fruits[right], 0) + 1);
                while (map.size() > 2) {
                    map.put(fruits[left], map.getOrDefault(fruits[left], 0) - 1);
                    if (map.get(fruits[left]) == 0) {
                        map.remove(fruits[left]);
                    }
                    left++;
                }
                ans = Math.max(ans, right - left + 1);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maxTotalFruits(int[][] fruits, int startPos, int k) {
            int n = fruits.length;
            int left = lowerBound(fruits, startPos - k);
            int ans = 0;
            int s = 0;
            for (int right = left; right < n && fruits[right][0] <= startPos + k; right++) {
                s += fruits[right][1];
                while (fruits[right][0] * 2 - fruits[left][0] - startPos > k &&
                        fruits[right][0] - fruits[left][0] * 2 + startPos > k) {
                    s -= fruits[left][1];
                    left++;
                }
                ans = Math.max(ans, s);
            }
            return ans;
        }

        private int lowerBound(int[][] fruits, int target) {
            int left = -1;
            int right = fruits.length;
            while (left + 1 < right) {
                int mid = left + (right - left) / 2;
                if (fruits[mid][0] < target) {
                    left = mid;
                } else {
                    right = mid;
                }
            }
            return right;
        }
    }*/

/*    class Solution {
        public long minCost(int[] basket1, int[] basket2) {
            Map<Integer, Integer> cnt = new HashMap<>();
            for (int i = 0; i < basket1.length; i++) {
                cnt.merge(basket1[i], 1, Integer::sum);
                cnt.merge(basket2[i], -1, Integer::sum);
            }
            List<Integer> a = new ArrayList<>();
            List<Integer> b = new ArrayList<>();
            int mn = Integer.MAX_VALUE;
            for (Map.Entry<Integer, Integer> e : cnt.entrySet()) {
                int x = e.getKey();
                int c = e.getValue();
                if (c % 2 != 0) {
                    return -1;
                }
                mn = Math.min(mn, x);
                if (c > 0) {
                    for (int i = 0; i < c / 2; i++) {
                        a.add(x);
                    }
                } else {
                    for (int i = 0; i < -c / 2; i++) {
                        b.add(x);
                    }
                }
            }
            Collections.sort(a);
            b.sort(Collections.reverseOrder());
            long ans = 0;
            for (int i = 0; i < a.size(); i++) {
                ans += Math.min(Math.min(a.get(i), b.get(i)), mn * 2);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public List<List<Integer>> generate(int numRows) {
            List<List<Integer>> ans = new ArrayList<>(numRows);
            ans.add(List.of(1));
            for (int i = 2; i <= numRows; i++) {
                List<Integer> row = new ArrayList<>(i);
                row.add(1);
                for (int j = 2; j < i; j++) {
                    row.add(ans.get(i - 2).get(j - 2) + ans.get(i - 2).get(j - 1));
                }
                row.add(1);
                ans.add(row);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public boolean doesValidArrayExist(int[] derived) {
            int ans = 0;
            for (int x : derived) {
                ans ^= x;
            }
            return ans == 0;
        }
    }*/

/*    class Solution {
        public int[] smallestSubarrays(int[] nums) {
            int n = nums.length;
            int[] ans = new int[n];
            for (int i = 0; i < n; i++) {
                int x = nums[i];
                ans[i] = 1;
                for (int j = i - 1; j >= 0 && (nums[j] | x) != nums[j]; j--) {
                    nums[j] |= x;
                    ans[j] = i - j + 1;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int countMaxOrSubsets(int[] nums) {
            int target = 0;
            for (int x : nums) {
                target |= x;
            }
            dfs(0, 0, nums, target);
            return ans;
        }

        private int ans = 0;

        private void dfs(int i, int orVal, int[] nums, int target) {
            if (i == nums.length) {
                if (orVal == target) {
                    ans++;
                }
                return;
            }
            dfs(i + 1, orVal, nums, target);
            dfs(i + 1, orVal | nums[i], nums, target);
        }
    }*/

/*    class Solution {
        public int countHillValley(int[] nums) {
            int k = 1;
            for (int i = 1; i < nums.length; i++) {
                if (nums[i] != nums[i - 1]) {
                    nums[k] = nums[i];
                    k++;
                }
            }
            int ans = 0;
            for (int i = 1; i < k - 1; i++) {
                if ((nums[i - 1] < nums[i]) == (nums[i] > nums[i + 1])) {
                    ans++;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public long maxSubarrays(int n, int[][] conflictingPairs) {
            List<Integer>[] groups = new ArrayList[n + 1];
            Arrays.setAll(groups, _ -> new ArrayList<>());
            for (int[] p : conflictingPairs) {
                int a = p[0];
                int b = p[1];
                groups[Math.min(a, b)].add(Math.max(a, b));
            }
            long ans = 0;
            long maxExtra = 0;
            long[] extra = new long[n + 2];
            List<Integer> b = new ArrayList<>();
            b.add(n + 1);
            b.add(n + 1);
            for (int i = n; i > 0; i--) {
                b.addAll(groups[i]);
                Collections.sort(b);
                b.subList(2, b.size()).clear();
                int b0 = b.get(0);
                ans += b0 - i;
                extra[b0] += b.get(1) - b0;
                maxExtra = Math.max(maxExtra, extra[b0]);
            }

            return ans + maxExtra;
        }
    }*/

/*    class Solution {
        public int maxSum(int[] nums) {
            Set<Integer> st = new HashSet<>();
            int sum = 0;
            int maxVal = Integer.MIN_VALUE;
            for (int x : nums) {
                if (x < 0) {
                    maxVal = Math.max(maxVal, x);
                } else if (!st.contains(x)) {
                    st.add(x);
                    sum += x;
                }
            }
            return st.isEmpty() ? maxVal : sum;
        }
    }*/

/*    class Solution {
        public static int MAX_N = 1001;
        public static int[] dfn = new int[MAX_N];
        public static int[] size = new int[MAX_N];
        public static int[] xor = new int[MAX_N];
        public static int dfnCnt;

        public static void build(int n) {
            Arrays.fill(dfn, 0, n, 0);
            dfnCnt = 0;
        }

        public int minimumScore(int[] nums, int[][] edges) {
            int n = nums.length;
            ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                graph.add(new ArrayList<>());
            }
            for (int[] edge : edges) {
                graph.get(edge[0]).add(edge[1]);
                graph.get(edge[1]).add(edge[0]);
            }
            build(n);
            f(nums, graph, 0);
            int m = edges.length;
            int ans = Integer.MAX_VALUE;
            for (int i = 0, a, b, pre, pos, sum1, sum2, sum3; i < m; i++) {
                a = Math.max(dfn[edges[i][0]], dfn[edges[i][1]]);
                for (int j = i + 1; j < m; j++) {
                    b = Math.max(dfn[edges[j][0]], dfn[edges[j][1]]);
                    if (a < b) {
                        pre = a;
                        pos = b;
                    } else {
                        pre = b;
                        pos = a;
                    }
                    sum1 = xor[pos];
                    if (pos < pre + size[pre]) {
                        sum2 = xor[pre] ^ xor[pos];
                        sum3 = xor[1] ^ xor[pre];
                    } else {
                        sum2 = xor[pre];
                        sum3 = xor[1] ^ sum1 ^ sum2;
                    }
                    ans = Math.min(ans, Math.max(Math.max(sum1, sum2), sum3) - Math.min(Math.min(sum1, sum2), sum3));
                }
            }
            return ans;
        }

        public static void f(int[] nums, ArrayList<ArrayList<Integer>> graph, int u) {
            int id = ++dfnCnt;
            dfn[u] = id;
            xor[id] = nums[u];
            size[id] = 1;
            for (int v : graph.get(u)) {
                if (dfn[v] == 0) {
                    f(nums, graph, v);
                    xor[id] ^= xor[dfn[v]];
                    size[id] += size[dfn[v]];
                }
            }
        }
    }*/

/*    class Solution {
        public int maximumGain(String s, int x, int y) {
            char a = 'a', b = 'b';
            if (x < y) {
                int t = x;
                x = y;
                y = t;
                char c = a;
                a = b;
                b = c;
            }
            int ans = 0, cnt1 = 0, cnt2 = 0;
            int n = s.length();
            for (int i = 0; i < n; ++i) {
                char c = s.charAt(i);
                if (c == a) {
                    cnt1++;
                } else if (c == b) {
                    if (cnt1 > 0) {
                        ans += x;
                        cnt1--;
                    } else {
                        cnt2++;
                    }
                } else {
                    ans += Math.min(cnt1, cnt2) * y;
                    cnt1 = 0;
                    cnt2 = 0;
                }
            }
            ans += Math.min(cnt1, cnt2) * y;
            return ans;
        }
    }*/

/*    class Solution {
        public int maximumUniqueSubarray(int[] nums) {
            int maxVal = 0;
            for (int x : nums) {
                maxVal = Math.max(maxVal, x);
            }
            boolean[] set = new boolean[maxVal + 1];
            int ans = 0;
            int sum = 0;
            int left = 0;
            for (int x : nums) {
                while (set[x]) {
                    set[nums[left]] = false;
                    sum -= nums[left];
                    left++;
                }
                set[x] = true;
                sum += x;
                ans = Math.max(ans, sum);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public String makeFancyString(String s) {
            int cnt = 0;
            StringBuilder sb = new StringBuilder();
            char[] sArr = s.toCharArray();
            for (int i = 0; i < sArr.length; i++) {
                cnt++;
                if (cnt < 3) {
                    sb.append(sArr[i]);
                }
                if (i < sArr.length - 1 && sArr[i] != sArr[i + 1]) {
                    cnt = 0;
                }
            }
            return sb.toString();
        }
    }*/

/*    class Solution {
        public String makeFancyString(String s) {
            int ans = 0;
            int cnt = 1;
            StringBuilder sb = new StringBuilder();
            char[] sArr = s.toCharArray();
            for (int i = 1; i < sArr.length; i++) {
                if (sArr[i] == sArr[i - 1]) {
                    cnt++;
                } else {
                    ans += Math.max(cnt - 2, 0);
                    if (cnt > 3) {
                        sb.delete(sb.length() - cnt + 2, sb.length());
                    }
                    cnt = 1;
                }
                sb.append(sArr[i]);
            }
            System.out.println(ans);
            return sb.toString();
        }
    }*/

/*    class Solution {
        private static class TrieNode {
            Map<String, TrieNode> son = new HashMap<>();
            String name;
            boolean deleted = false;
        }

        public List<List<String>> deleteDuplicateFolder(List<List<String>> paths) {
            TrieNode root = new TrieNode();
            for (List<String> path : paths) {
                TrieNode cur = root;
                for (String s : path) {
                    if (!cur.son.containsKey(s)) {
                        cur.son.put(s, new TrieNode());
                    }
                    cur = cur.son.get(s);
                    cur.name = s;
                }
            }

            Map<String, TrieNode> exprToNode = new HashMap<>();
            for (TrieNode son : root.son.values()) {
                genExpr(son, exprToNode);
            }

            List<List<String>> ans = new ArrayList<>();
            LinkedList<String>  path = new LinkedList<>();
            for (TrieNode son : root.son.values()) {
                dfs(son, path, ans);
            }
            return ans;
        }

        private String genExpr(TrieNode node, Map<String, TrieNode> exprToNode) {
            if (node.son.isEmpty()) {
                return node.name;
            }

            List<String> expr = new ArrayList<>();
            for (TrieNode son : node.son.values()) {
                expr.add("(" + genExpr(son, exprToNode) + ")");
            }
            Collections.sort(expr);

            String subTreeExpr = String.join("", expr);
            TrieNode n = exprToNode.get(subTreeExpr);
            if (n != null) {
                n.deleted = true;
                node.deleted = true;
            } else {
                exprToNode.put(subTreeExpr, node);
            }

            return node.name + subTreeExpr;
        }

        private void dfs(TrieNode node, LinkedList<String> path, List<List<String>> ans) {
            if (node.deleted) {
                return;
            }
            path.add(node.name);
            ans.add(new ArrayList<>(path));
            for (TrieNode son : node.son.values()) {
                dfs(son, path, ans);
            }
            path.removeLast();
        }
    }*/

/*    class Solution {
        public List<String> removeSubfolders(String[] folder) {
            Arrays.sort(folder);
            LinkedList<String> ans = new LinkedList<>();
            ans.add(folder[0]);
            for (int i = 1; i < folder.length; i++) {
                String s = folder[i];
                String last = ans.getLast();
                if (!s.startsWith(last) || s.charAt(last.length()) != '/') {
                    ans.add(s);
                }
            }
            return ans;
        }
    }*/

    /*class Solution {
        public long minimumDifference(int[] nums) {
            int m = nums.length;
            int n = m / 3;
            PriorityQueue<Integer> minPQ = new PriorityQueue<>();
            long sum = 0;
            for (int i = m - 1; i >= m - n; i--) {
                minPQ.offer(nums[i]);
                sum += nums[i];
            }

            long[] sufMax = new long[m - n + 1];
            sufMax[m - n] = sum;
            for (int i = m - n - 1; i >= n; i--) {
                int v = nums[i];
                if (v > minPQ.peek()) {
                    sum += v - minPQ.poll();
                    minPQ.offer(v);
                }
                sufMax[i] = sum;
            }

            PriorityQueue<Integer> maxPQ = new PriorityQueue<>((a, b) -> b - a);
            long preMin = 0;
            for (int i = 0; i < n; ++i) {
                maxPQ.offer(nums[i]);
                preMin += nums[i];
            }

            long ans = preMin - sufMax[n];
            for (int i = n; i < m - n; i++) {
                int v = nums[i];
                if (v < maxPQ.peek()) {
                    preMin += v - maxPQ.poll();
                    maxPQ.offer(v);
                }
                ans = Math.min(ans, preMin - sufMax[i + 1]);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maximumLength(int[] nums, int k) {
            int ans = 0;
            int[][] dp = new int[k][k];
            for (int x : nums) {
                x %= k;
                for (int y = 0; y < k; y++) {
                    dp[y][x] = dp[x][y] + 1;
                    ans = Math.max(ans, dp[y][x]);
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maximumLength(int[] nums) {
            int allZero = 0, allOne = 0, one = 0, zero = 0;
            for (int num : nums) {
                if (num % 2 == 0) {
                    allZero++;
                    zero = Math.max(zero, one + 1);
                } else {
                    allOne++;
                    one = Math.max(one, zero + 1);
                }
            }
            return Math.max(Math.max(allZero, allOne), Math.max(zero, one));
        }
    }*/

    /*class Solution {
        public boolean isValid(String words) {
            if (words.length() < 3) {
                return false;
            }
            boolean flag1 = false;
            boolean flag2 = false;
            char[] word = words.toCharArray();
            for (int i = 0; i < word.length; i++) {
                if (word[i] == '@' || word[i] == '#' || word[i] == '$') {
                    return false;
                }
                if (word[i] == 'a' || word[i] == 'e' || word[i] == 'i' || word[i] == 'o' || word[i] == 'u' || word[i] == 'A'
                        || word[i] == 'E' || word[i] == 'I' || word[i] == 'O' || word[i] == 'U') {
                    flag1 = true;
                } else if (word[i] >= '9') {
                    flag2 = true;
                }
            }
            if (flag1 && flag2) {
                return true;
            }
            return false;
        }
    }*/

/*    class Solution {
        public int getDecimalValue(ListNode head) {
            int ans = 0;
            ListNode tmp = head;
            while (tmp != null) {
                ans = ans * 2 + tmp.val;
                tmp = tmp.next;
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int matchPlayersAndTrainers(int[] players, int[] trainers) {
            int n = players.length;
            int m = trainers.length;
            Arrays.sort(players);
            Arrays.sort(trainers);
            int left = 0;
            int right = 0;
            while (left < n && right < m) {
                if (players[left] <= trainers[right]) {
                    left++;
                }
                right++;
            }
            return left;
        }
    }*/

    /*class Solution {
        public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
            int[][][][] dp = new int[n + 1][n + 1][n + 1][2];
            return dfs(n, firstPlayer, secondPlayer, dp);
        }

        private int[] dfs(int n, int first, int second, int[][][][] dp) {
            if (first + second == n + 1) {
                return new int[]{1, 1};
            }
            if (first + second > n + 1) {
                int tmp = first;
                first = n + 1 - second;
                second = n + 1 - tmp;
            }
            int[] mem = dp[n][first][second];
            if (mem[0] > 0) {
                return mem;
            }

            int m = (n + 1) / 2;
            int minMid = second <= m ? 0 : second - n / 2 - 1;
            int maxMid = second <= m ? second - first : m - first;
            int earliest = Integer.MAX_VALUE;
            int latest = 0;

            for (int left = 0; left < first; left++) {
                for (int mid = minMid; mid < maxMid; mid++) {
                    int[] res = dfs(m, left + 1, left + mid + 2, dp);
                    earliest = Math.min(earliest, res[0]);
                    latest = Math.max(latest, res[1]);
                }
            }
            mem[0] = earliest + 1;
            mem[1] = latest + 1;
            return mem;
        }
    }*/

/*    class Solution {
        public int countDays(int days, int[][] meetings) {
            Arrays.sort(meetings, (x, y) -> x[0] - y[0]);
            int start = 1;
            int end = 0;
            for (int[] x : meetings) {
                if (x[0] > end) {
                    days -= end - start + 1;
                    start = x[0];
                }
                end = Math.max(end, x[1]);
            }
            days -= end - start + 1;
            return days;
        }
    }*/

/*    class Solution {
        public int countDays(int days, int[][] meetings) {
            meetings = merge(meetings);
            for (int[] x : meetings) {
                days -= x[1] - x[0] + 1;
            }
            return days;
        }

        public int[][] merge(int[][] intervals) {
            Arrays.sort(intervals, (x, y) -> x[0] - y[0]);
            int n = intervals.length;
            int preEnd = intervals[0][1];
            int preIndex = 0;
            ArrayList<int[]> ans = new ArrayList<>();
            for (int i = 1; i < n; i++) {
                if (intervals[i][0] <= preEnd) {
                    preEnd = Math.max(preEnd, intervals[i][1]);
                } else {
                    ans.add(new int[] { intervals[preIndex][0], preEnd });
                    preEnd = intervals[i][1];
                    preIndex = i;
                }
            }
            ans.add(new int[] { intervals[preIndex][0], preEnd });
            return ans.toArray(new int[ans.size()][]);
        }
    }*/

/*    class Solution {
        private int eventTime;
        private int[] startTime, endTime;

        public int maxFreeTime(int eventTime, int[] startTime, int[] endTime) {
            this.eventTime = eventTime;
            this.startTime = startTime;
            this.endTime = endTime;
            int n = startTime.length;

            int a = 0, b = -1, c = -1;
            for (int i = 1; i <= n; i++) {
                int sz = get(i);
                if (sz > get(a)) {
                    c = b; b = a; a = i;
                } else if (b < 0 || sz > get(b)) {
                    c = b; b = i;
                } else if (c < 0 || sz > get(c)) {
                    c = i;
                }
            }

            int ans = 0;
            for (int i = 0; i < n; i++) {
                int sz = endTime[i] - startTime[i];
                if (i != a && i + 1 != a && sz <= get(a) ||
                        i != b && i + 1 != b && sz <= get(b) ||
                        sz <= get(c)) {
                    ans = Math.max(ans, get(i) + sz + get(i + 1));
                } else {
                    ans = Math.max(ans, get(i) + get(i + 1));
                }
            }
            return ans;
        }

        private int get(int i) {
            if (i == 0) {
                return startTime[0];
            }
            int n = startTime.length;
            if (i == n) {
                return eventTime - endTime[n - 1];
            }
            return startTime[i] - endTime[i - 1];
        }
    }*/

    /*class Solution {
        public int maxFreeTime(int eventTime, int k, int[] startTime, int[] endTime) {
            int ans = 0;
            int sum = 0;
            for (int i = 0; i <= startTime.length; i++) {
                sum += solve(i, eventTime, startTime, endTime);
                if (i < k) {
                    continue;
                }
                ans = Math.max(ans, sum);
                sum -= solve(i - k, eventTime, startTime, endTime);
            }
            return ans;
        }

        public int solve(int i, int eventTime, int[] startTime, int[] endTime) {
            if (i == 0) {
                return startTime[0];
            }
            int n = startTime.length;
            if (i == n) {
                return eventTime - endTime[n - 1];
            }
            return startTime[i] - endTime[i - 1];
        }
    }*/

/*    class Solution {
        public int maxFreeTime(int eventTime, int k, int[] startTime, int[] endTime) {
            int n = startTime.length;
            int[] group = new int[n + 1];
            group[0] = startTime[0];
            for (int i = 1; i < n; i++) {
                group[i] = startTime[i] - endTime[i - 1];
            }
            group[n] = eventTime - endTime[n - 1];
            int ans = 0;
            int sum = 0;
            for (int i = 0; i <= n; i++) {
                sum += group[i];
                if (i < k) {
                    continue;
                }
                ans = Math.max(ans, sum);
                sum -= group[i - k];
            }
            return ans;
        }
    }*/

    /*class Solution {
        public int maxValue(int[][] events, int k) {
            Arrays.sort(events, (a, b) -> a[1] - b[1]);
            int n = events.length;
            int[][] dp = new int[n + 1][k + 1];
            for (int i = 0; i < n; i++) {
                int p = search(events, i, events[i][0]);
                for (int j = 1; j <= k; j++) {
                    dp[i + 1][j] = Math.max(dp[i][j], dp[p + 1][j - 1] + events[i][2]);
                }
            }
            return dp[n][k];
        }

        private int search(int[][] events, int right, int upper) {
            int left = -1;
            while (left + 1 < right) {
                int mid = left + (right - left) / 2;
                if (events[mid][1] < upper) {
                    left = mid;
                } else {
                    right = mid;
                }
            }
            return left;
        }
    }*/

/*    class Solution {
        public int maxEvents(int[][] events) {
            int n = events.length;
            Arrays.sort(events, (a, b) -> a[0] - b[0]);
            int min = events[0][0];
            int max = events[0][1];
            for (int i = 1; i < n; i++) {
                max = Math.max(max, events[i][1]);
            }
            PriorityQueue<Integer> heap = new PriorityQueue<>();
            int ans = 0;
            for (int day = min,i = 0; day <= max; day++) {
                while (i < n && events[i][0] == day) {
                    heap.add(events[i++][1]);
                }
                while (!heap.isEmpty() && heap.peek() < day) {
                    heap.poll();
                }
                if (!heap.isEmpty()) {
                    heap.poll();
                    ans++;
                }
            }
            return ans;
        }
    }*/

/*    class FindSumPairs {
        private Map<Integer, Integer> cnt = new HashMap<>();

        private int[] arr1;

        private int[] arr2;

        public FindSumPairs(int[] nums1, int[] nums2) {
            for (int i = 0; i < nums2.length; i++) {
                cnt.put(nums2[i], cnt.getOrDefault(nums2[i], 0) + 1);
            }
            arr1 = nums1;
            arr2 = nums2;
        }

        public void add(int index, int val) {
            int x = arr2[index];
            cnt.put(x, cnt.get(x) - 1);
            cnt.put(x + val, cnt.getOrDefault(x + val, 0) + 1);
            arr2[index] += val;
        }

        public int count(int tot) {
            int ans = 0;
            for (int x : arr1) {
                ans += cnt.getOrDefault(tot - x, 0);
            }
            return ans;
        }
    }*/

/**
 * Your FindSumPairs object will be instantiated and called as such:
 * FindSumPairs obj = new FindSumPairs(nums1, nums2);
 * obj.add(index,val);
 * int param_2 = obj.count(tot);
 */

/*    class Solution {
        public static final int MAX_N = 501;

        public static int[] map = new int[MAX_N];

        public static void clear() {
            for (int i = 0; i < MAX_N; i++) {
                map[i] = 0;
            }
        }

        public int findLucky(int[] arr) {
            clear();
            for (int x : arr) {
                map[x]++;
            }
            for (int i = MAX_N - 1; i > 0; i--) {
                if (map[i] == i) {
                    return i;
                }
            }
            return -1;
        }
    }*/

/*    class Solution {
        public char kthCharacter(long k, int[] operations) {
            return f(k, operations, 63 - Long.numberOfLeadingZeros(k - 1));
        }

        private char f(long k, int[] operations, int i) {
            if (i < 0) {
                return 'a';
            }
            int op = operations[i];
            if (k <= (1L << i)) {
                return f(k, operations, i - 1);
            }
            char ans = f(k - (1L << i), operations, i - 1);
            return (char) ('a' + (ans - 'a' + op) % 26);
        }
    }*/

/*    class Solution {
        public char kthCharacter(int k) {
            String s = "a";
            while(s.length()<k){
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < s.length(); i++) {
                    sb.append((s.charAt(i)+1)>'z'?(char)(s.charAt(i)-26):(char) (s.charAt(i)+1));
                }
                s = s+sb.toString();
            }
            return s.charAt(k-1);
        }
    }*/

/*    class Solution {
        public int possibleStringCount(String word, int k) {
            int n = word.length();
            if (n < k) {
                return 0;
            }
            final int MOD = 1_000_000_007;
            List<Integer> cnts = new ArrayList<>();
            long ans = 1;
            int cnt = 0;
            for (int i = 0; i < n; i++) {
                cnt++;
                if (i == n - 1 || word.charAt(i) != word.charAt(i + 1)) {
                    if (cnt > 1) {
                        if (k > 0) {
                            cnts.add(cnt - 1);
                        }
                        ans = ans * cnt % MOD;
                    }
                    k--;
                    cnt = 0;
                }
            }
            if (k <= 0) {
                return (int) ans;
            }
            int m = cnts.size();
            int[][] f = new int[m + 1][k];
            Arrays.fill(f[0], 1);
            int[] s = new int[k + 1];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < k; j++) {
                    s[j + 1] = (s[j] + f[i][j]) % MOD;
                }
                int c = cnts.get(i);
                for (int j = 0; j < k; j++) {
                    f[i + 1][j] = (s[j + 1] - s[Math.max(j - c, 0)]) % MOD;
                }
            }

            return (int) ((ans - f[m][k - 1] + MOD) % MOD);
        }
    }*/

/*    class Solution {
        public int possibleStringCount(String word) {
            int result = 0;
            for (int i = 1; i < word.length(); i++) {
                if (word.charAt(i) == word.charAt(i - 1)) {
                    result++;
                }
            }
            return result + 1;
        }
    }*/

/*    class Solution {
        public int findLHS(int[] nums) {
            int n = nums.length;
            HashMap<Integer,Integer> map = new HashMap<>();
            for(int i = 0;i<n;i++){
                map.put(nums[i],map.getOrDefault(nums[i],0)+1);
            }
            int ans = 0;
            for (Map.Entry<Integer, Integer> e : map.entrySet()) {
                Integer x = e.getKey();
                Integer y = x + 1;
                if (map.containsKey(y)) {
                    ans = Math.max(ans, e.getValue() + map.get(y));
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        private static final int MOD = 1_000_000_007;
        private static final int[] pow2 = new int[100_000];
        private static boolean initialized = false;

        private void init() {
            if (initialized) {
                return;
            }
            initialized = true;
            pow2[0] = 1;
            for (int i = 1; i < pow2.length; i++) {
                pow2[i] = pow2[i - 1] * 2 % MOD;
            }
        }

        public int numSubseq(int[] nums, int target) {
            init();
            Arrays.sort(nums);
            long ans = 0;
            int left = 0;
            int right = nums.length - 1;
            while (left <= right) {
                if (nums[left] + nums[right] <= target) {
                    ans += pow2[right - left];
                    left++;
                } else {
                    right--;
                }
            }
            return (int) (ans % MOD);
        }
    }*/

/*    class Solution {
        public int[] maxSubsequence(int[] nums, int k) {
            Integer[] idx = new Integer[nums.length];
            Arrays.setAll(idx, i -> i);
            Arrays.sort(idx, (i, j) -> nums[j] - nums[i]);
            int[] ans = new int[k];
            for (int i = 0; i < k; i++) {
                ans[i] = idx[i];
            }
            Arrays.sort(ans);
            for (int i = 0; i < k; i++) {
                ans[i] = nums[ans[i]];
            }
            return ans;
        }
    }*/

/*    class Solution {
        private char[] ans;
        private int ansLen = 0;

        public String longestSubsequenceRepeatedK(String S, int k) {
            char[] s = S.toCharArray();

            int[] cnt = new int[26];
            for (char c : s) {
                cnt[c - 'a']++;
            }

            StringBuilder tmp = new StringBuilder();
            for (int i = 25; i >= 0; i--) {
                String c = String.valueOf((char) ('a' + i));
                tmp.append(c.repeat(cnt[i] / k));
            }
            char[] a = tmp.toString().toCharArray();

            ans = new char[a.length];
            permute(a, k, s);

            return new String(ans, 0, ansLen);
        }
        private void permute(char[] nums, int k, char[] s) {
            int n = nums.length;
            char[] path = new char[n];
            boolean[] onPath = new boolean[n];
            dfs(0, nums, path, onPath, k, s);
        }

        private void dfs(int i, char[] nums, char[] path, boolean[] onPath, int k, char[] s) {
            process(path, i, k, s);

            if (i == nums.length) {
                return;
            }

            for (int j = 0; j < nums.length; j++) {
                if (onPath[j] || j > 0 && nums[j] == nums[j - 1] && !onPath[j - 1]) {
                    continue;
                }
                path[i] = nums[j];
                onPath[j] = true;
                dfs(i + 1, nums, path, onPath, k, s);
                onPath[j] = false;
            }
        }

        private void process(char[] seq, int seqLen, int k, char[] s) {
            if (seqLen > ansLen || seqLen == ansLen && compare(seq, ans, ansLen) > 0) {
                if (isSubsequence(seq, seqLen, k, s)) {
                    System.arraycopy(seq, 0, ans, 0, seqLen);
                    ansLen = seqLen;
                }
            }
        }

        private int compare(char[] a, char[] b, int n) {
            for (int i = 0; i < n; i++) {
                if (a[i] != b[i]) {
                    return a[i] - b[i];
                }
            }
            return 0;
        }

        private boolean isSubsequence(char[] seq, int n, int k, char[] s) {
            int i = 0;
            for (char c : s) {
                if (seq[i % n] == c) {
                    i++;
                    if (i == n * k) {
                        return true;
                    }
                }
            }
            return false;
        }
    }*/

/*    class Solution {
        public int longestSubsequence(String s, int k) {
            int n = s.length();
            int m = 32 - Integer.numberOfLeadingZeros(k);
            if (n < m) {
                return n;
            }
            int sufVal = Integer.parseInt(s.substring(n - m), 2);
            int ans = sufVal <= k ? m : m - 1;
            for (int i = 0; i < n - m; i++) {
                ans += '1' - s.charAt(i);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public long kthSmallestProduct(int[] a, int[] b, long k) {
            int i0 = lowerBound(a, 0);
            int j0 = lowerBound(b, 0);

            int n = a.length;
            int m = b.length;
            List<Long> corners = Arrays.asList((long) a[0] * b[0], (long) a[0] * b[m - 1], (long) a[n - 1] * b[0], (long) a[n - 1] * b[m - 1]);
            long left = Collections.min(corners) - 1;
            long right = Collections.max(corners);

            while (left + 1 < right) {
                long mid = left + (right - left) / 2;
                if (check(a, b, i0, j0, k, mid)) {
                    right = mid;
                } else {
                    left = mid;
                }
            }
            return right;
        }

        private boolean check(int[] a, int[] b, int i0, int j0, long k, long mx) {
            int n = a.length;
            int m = b.length;
            long cnt = 0;

            if (mx < 0) {
                int i = 0;
                int j = j0;
                while (i < i0 && j < m) {
                    if ((long) a[i] * b[j] > mx) {
                        j++;
                    } else {
                        cnt += m - j;
                        i++;
                    }
                }

                i = i0;
                j = 0;
                while (i < n && j < j0) {
                    if ((long) a[i] * b[j] > mx) {
                        i++;
                    } else {
                        cnt += n - i;
                        j++;
                    }
                }
            } else {
                cnt = (long) i0 * (m - j0) + (long) (n - i0) * j0;

                int i = 0;
                int j = j0 - 1;
                while (i < i0 && j >= 0) {
                    if ((long) a[i] * b[j] > mx) {
                        i++;
                    } else {
                        cnt += i0 - i;
                        j--;
                    }
                }

                i = i0;
                j = m - 1;
                while (i < n && j >= j0) {
                    if ((long) a[i] * b[j] > mx) {
                        j--;
                    } else {
                        cnt += j - j0 + 1;
                        i++;
                    }
                }
            }

            return cnt >= k;
        }

        private int lowerBound(int[] nums, int target) {
            int left = -1;
            int right = nums.length;
            while (left + 1 < right) {
                int mid = left + (right - left) / 2;
                if (nums[mid] >= target) {
                    right = mid;
                } else {
                    left = mid;
                }
            }
            return right;
        }
    }*/

/*    class Solution {
        public List<Integer> findKDistantIndices(int[] nums, int key, int k) {
            int last = -k - 1;
            for (int i = k - 1; i >= 0; i--) {
                if (nums[i] == key) {
                    last = i;
                    break;
                }
            }
            int n = nums.length;
            List<Integer> ans = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (i + k < n && nums[i + k] == key) {
                    last = i + k;
                }
                if (last >= i - k) {
                    ans.add(i);
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        private static final int MAX_N = 30;
        private static final List<Long>[] ans = new ArrayList[10];
        private static boolean initialized = false;

        // 这样写比 static block 快
        private void init() {
            if (initialized) {
                return;
            }
            initialized = true;

            Arrays.setAll(ans, i -> new ArrayList<>());
            for (int base = 1; ; base *= 10) {
                // 生成奇数长度回文数，例如 base = 10，生成的范围是 101 ~ 999
                for (int i = base; i < base * 10; i++) {
                    long x = i;
                    for (int t = i / 10; t > 0; t /= 10) {
                        x = x * 10 + t % 10;
                    }
                    if (doPalindrome(x)) {
                        return;
                    }
                }
                // 生成偶数长度回文数，例如 base = 10，生成的范围是 1001 ~ 9999
                for (int i = base; i < base * 10; i++) {
                    long x = i;
                    for (int t = i; t > 0; t /= 10) {
                        x = x * 10 + t % 10;
                    }
                    if (doPalindrome(x)) {
                        return;
                    }
                }
            }
        }

        private boolean doPalindrome(long x) {
            boolean done = true;
            for (int k = 2; k < 10; k++) {
                if (ans[k].size() < MAX_N && isKPalindrome(x, k)) {
                    ans[k].add(x);
                }
                if (ans[k].size() < MAX_N) {
                    done = false;
                }
            }
            if (!done) {
                return false;
            }

            for (int k = 2; k < 10; k++) {
                // 原地求前缀和
                List<Long> s = ans[k];
                for (int i = 1; i < MAX_N; i++) {
                    s.set(i, s.get(i) + s.get(i - 1));
                }
            }
            return true;
        }

        // 力扣 9. 回文数
        private boolean isKPalindrome(long x, int k) {
            if (x % k == 0) {
                return false;
            }
            int rev = 0;
            while (rev < x / k) {
                rev = rev * k + (int) (x % k);
                x /= k;
            }
            return rev == x || rev == x / k;
        }

        public long kMirror(int k, int n) {
            init();
            return ans[k].get(n - 1);
        }
    }*/

/*    class Solution {
        public String[] divideString(String s, int k, char fill) {
            int n = s.length();
            String[] ans = new String[(n + k - 1) / k];
            for (int i = 0; i < n; i += k) {
                if (i + k <= n) {
                    ans[i / k] = s.substring(i, i + k);
                } else {
                    ans[i / k] = s.substring(i) + String.valueOf(fill).repeat(k - n + i);
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int minimumDeletions(String word, int k) {
            int[] cnt = new int[26];
            for (char c : word.toCharArray()) {
                cnt[c - 'a']++;
            }
            Arrays.sort(cnt);
            int ans = 0;
            for (int i = 0; i < 26; i++) {
                int sum = 0;
                for (int j = i; j < 26; j++) {
                    sum += Math.min(cnt[j], cnt[i] + k);
                }
                ans = Math.max(ans, sum);
            }
            return word.length() - ans;
        }
    }*/

/*    class Solution {
        public int maxDistance(String s, int k) {
            int ans = 0;
            int x = 0;
            int y = 0;
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c == 'N') {
                    y++;
                } else if (c == 'S') {
                    y--;
                } else if (c == 'E') {
                    x++;
                } else {
                    x--;
                }
                ans = Math.max(ans, Math.min(Math.abs(x) + Math.abs(y) + k * 2, i + 1));
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int partitionArray(int[] nums, int k) {
            Arrays.sort(nums);
            int n = nums.length;
            int ans = 1;
            int flag = 0;
            for (int i = 0; i < n; i++) {
                if (nums[i] - nums[flag] > k) {
                    ans++;
                    flag = i;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int[][] divideArray(int[] nums, int k) {
            Arrays.sort(nums);
            int n = nums.length;
            int[][] ans = new int[n / 3][];
            for (int i = 2; i < n; i += 3) {
                if (nums[i] - nums[i - 2] > k) {
                    return new int[][] {};
                }
                ans[i / 3] = new int[] { nums[i - 2], nums[i - 1], nums[i] };
            }
            return ans;
        }
    }*/

/*    class Solution {
        private static final int MOD = 1_000_000_007;
        private static final int MAXN = 100_000;

        private static final long[] fac = new long[MAXN];
        private static final long[] invF = new long[MAXN];

        private static boolean initialized = false;

        private void init() {
            if (initialized) {
                return;
            }
            initialized = true;
            fac[0] = 1;
            for (int i = 1; i < MAXN; i++) {
                fac[i] = fac[i - 1] * i % MOD;
            }
            invF[MAXN - 1] = pow(fac[MAXN - 1], MOD - 2);
            for (int i = MAXN - 1; i > 0; i--) {
                invF[i - 1] = invF[i] * i % MOD;
            }
        }

        private long pow(long x, int n) {
            long res = 1;
            for (; n > 0; n /= 2) {
                if (n % 2 > 0) {
                    res = res * x % MOD;
                }
                x = x * x % MOD;
            }
            return res;
        }

        private long comb(int n, int m) {
            return fac[n] * invF[m] % MOD * invF[n - m] % MOD;
        }

        public int countGoodArrays(int n, int m, int k) {
            init();
            return (int) (comb(n - 1, k) * m % MOD * pow(m - 1, n - k - 1) % MOD);
        }
    }*/

/*    class Solution {
        public int maximumDifference(int[] nums) {
            int n = nums.length;
            int ans = -1;
            int pre = nums[0];
            for (int i = 1; i < n; ++i) {
                if (nums[i] > pre) {
                    ans = Math.max(ans, nums[i] - pre);
                } else {
                    pre = nums[i];
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maxDiff(int num) {
            String s = String.valueOf(num);
            char[] sArr = s.toCharArray();
            int maxVal = num;
            for (char c : sArr) {
                if (c != '9') {
                    maxVal =  Integer.parseInt(s.replace(c, '9'));
                    break;
                }
            }
            int minVal = num;
            if (sArr[0] != '1') {
                minVal = Integer.parseInt(s.replace(sArr[0], '1'));
            } else {
                for (int i = 1; i < sArr.length; i++) {
                    if (sArr[i] > '1') {
                        minVal = Integer.parseInt(s.replace(sArr[i], '0'));
                        break;
                    }
                }
            }
            return maxVal - minVal;
        }
    }*/

    /*class Solution {
        public int minMaxDifference(int num) {
            String s = String.valueOf(num);
            int maxVal = num;
            char[] sArray = s.toCharArray();
            for (char c : sArray) {
                if (c != '9') {
                    maxVal = Integer.parseInt(s.replace(c, '9'));
                    break;
                }
            }
            int minVal = Integer.parseInt(s.replace(s.charAt(0), '0'));
            return maxVal - minVal;
        }
    }*/

/*    class Solution {

        public static int n;

        public int minimizeMax(int[] nums, int p) {
            n = nums.length;
            if (p == 0 || n == 1) {
                return 0;
            }
            Arrays.sort(nums);
            int left = -1;
            int right = nums[n - 1] - nums[0];
            while (left + 1 < right) {
                int mid = (left + right) >>> 1;
                if (check(mid, nums, p)) {
                    right = mid;
                } else {
                    left = mid;
                }
            }
            return right;
        }

        private boolean check(int mid, int[] nums, int p) {
            int cnt = 0;
            for (int i = 0; i < n - 1; i++) {
                if (nums[i + 1] - nums[i] <= mid) {
                    cnt++;
                    i++;
                }
            }
            return cnt >= p;
        }
    }*/

/*    class Solution {
        public int maxAdjacentDistance(int[] nums) {
            int n = nums.length;
            int ans = Math.abs(nums[0] - nums[n - 1]);
            for (int i = 1; i < n; i++) {
                ans = Math.max(ans, Math.abs(nums[i - 1] - nums[i]));
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maxDifference(String S, int k) {
            final int INF = Integer.MAX_VALUE / 2;
            char[] s = S.toCharArray();
            int ans = -INF;
            for (int x = 0; x < 5; x++) {
                for (int y = 0; y < 5; y++) {
                    if (y == x) {
                        continue;
                    }
                    int[] curS = new int[5];
                    int[] preS = new int[5];
                    int[][] minS = { { INF, INF }, { INF, INF } };
                    int left = 0;
                    for (int i = 0; i < s.length; i++) {
                        curS[s[i] - '0']++;
                        int r = i + 1;
                        while (r - left >= k && curS[x] > preS[x] && curS[y] > preS[y]) {
                            int p = preS[x] & 1;
                            int q = preS[y] & 1;
                            minS[p][q] = Math.min(minS[p][q], preS[x] - preS[y]);
                            preS[s[left] - '0']++;
                            left++;
                        }
                        ans = Math.max(ans, curS[x] - curS[y] - minS[curS[x] & 1 ^ 1][curS[y] & 1]);
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int maxDifference(String s) {
            int[] cnt = new int[26];
            for (char c : s.toCharArray()) {
                cnt[c - 'a']++;
            }
            int ji = 0;
            int ou = Integer.MAX_VALUE;
            for (int c : cnt) {
                if (c % 2 > 0) {
                    ji = Math.max(ji, c);
                } else if (c > 0) {
                    ou = Math.min(ou, c);
                }
            }
            return ji - ou;
        }
    }*/

/*    class Solution {
        public int findKthNumber(int n, int k) {
            int node = 1;
            k--;
            while (k > 0) {
                int size = countSubtreeSize(n, node);
                if (size <= k) {
                    node++;
                    k -= size;
                } else {
                    node *= 10;
                    k--;
                }
            }
            return node;
        }

        private int countSubtreeSize(int n, int node) {
            int size = 0;
            long left = node;
            long right = node + 1;
            while (left <= n) {
                size += Math.min(right, n + 1) - left;
                left *= 10;
                right *= 10;
            }
            return size;
        }
    }*/

/*    class Solution {
        public List<Integer> lexicalOrder(int n) {
            List<Integer> ans = new ArrayList<>();
            for (int i = 0, j = 1; i < n; i++) {
                ans.add(j);
                if (j * 10 <= n) {
                    j *= 10;
                } else {
                    while (j % 10 == 9 || j + 1 > n) {
                        j /= 10;
                    }
                    j++;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public String clearStars(String s) {
            char[] sArr = s.toCharArray();
            int n = sArr.length;
            List<Integer>[] stacks = new ArrayList[26];
            Arrays.setAll(stacks, i -> new ArrayList<>());
            for (int i = 0; i < n; i++) {
                if (sArr[i] != '*') {
                    stacks[sArr[i] - 'a'].add(i);
                    continue;
                }
                for (List<Integer> st : stacks) {
                    if (!st.isEmpty()) {
                        sArr[st.remove(st.size() - 1)] = '*';
                        break;
                    }
                }
            }
            int idx = 0;
            for (int i = 0; i < n; i++) {
                if (sArr[i] != '*') {
                    sArr[idx++] = sArr[i];
                }
            }
            return new String(sArr, 0, idx);
        }
    }*/

/*    class Solution {

        public static final int MAX_N = 100010;

        public static char[] st = new char[MAX_N];
        public String robotWithString(String s) {
            char[] sArr = s.toCharArray();
            int n = sArr.length;
            char[] sufMin = new char[n + 1];
            sufMin[n] = Character.MAX_VALUE;
            for (int i = n - 1; i >= 0; i--) {
                sufMin[i] = (char) Math.min(sufMin[i + 1], sArr[i]);
            }
            char[] ans = new char[n];
            int idx = 0;
            int top = -1;
            for (int i = 0; i < n; i++) {
                st[++top] = sArr[i];
                while (top >= 0 && st[top] <= sufMin[i + 1]) {
                    ans[idx++] = st[top--];
                }
            }
            return new String(ans);
        }
    }*/

/*    class Solution {
        public static int MAX_N = 50;

        public static int[] father = new int[MAX_N];

        public static void build(int n) {
            for (int i = 0; i <= n; i++) {
                father[i] = i;
            }
        }

        public static int find(int x) {
            if (x != father[x]) {
                father[x] = find(father[x]);
            }
            return father[x];
        }

        public static void union(int x, int y) {
            int fx = find(x);
            int fy = find(y);
            if (fx != fy) {
                if (fx < fy) {
                    father[fy] = fx;
                } else {
                    father[fx] = fy;
                }
            }
        }

        public String smallestEquivalentString(String s1, String s2, String baseStr) {
            build(26);
            int n = s1.length();
            for (int i = 0; i < n; i++) {
                union(s1.charAt(i) - 'a', s2.charAt(i) - 'a');
            }
            StringBuffer sb = new StringBuffer();
            int m = baseStr.length();
            for (int i = 0; i < m; i++) {
                int cur = baseStr.charAt(i) - 'a';
                int ch = find(cur);
                sb.append((char) ('a' + ch));
            }
            return sb.toString();
        }
    }*/

/*    class Solution {
        public String answerString(String s, int k) {
            if (k == 1) {
                return s;
            }
            int n = s.length();
            String ans = "";
            for (int i = 0; i < n; i++) {
                String sub = s.substring(i, Math.min(i + n - (k - 1), n));
                if (sub.compareTo(ans) > 0) {
                    ans = sub;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        private int ans = 0;

        public static final int MAX_N = 1001;

        public static int[] hasKey = new int[MAX_N];

        public static boolean[] hasBox = new boolean[MAX_N];

        public int maxCandies(int[] status, int[] candies, int[][] keys, int[][] containedBoxes, int[] initialBoxes) {
            hasKey = status;
            clear(status.length);
            for (int x : initialBoxes) {
                hasBox[x] = true;
            }
            for (int x : initialBoxes) {
                if (hasBox[x] && hasKey[x] == 1) {
                    dfs(x, candies, keys, containedBoxes);
                }
            }
            return ans;
        }

        private void clear(int n) {
            for (int i = 0; i <= n; i++) {
                hasBox[i] = false;
            }
        }

        private void dfs(int x, int[] candies, int[][] keys, int[][] containedBoxes) {
            ans += candies[x];
            hasBox[x] = false;

            for (int y : keys[x]) {
                hasKey[y] = 1;
                if (hasBox[y]) {
                    dfs(y, candies, keys, containedBoxes);
                }
            }

            for (int y : containedBoxes[x]) {
                hasBox[y] = true;
                if (hasKey[y] == 1) {
                    dfs(y, candies, keys, containedBoxes);
                }
            }
        }
    }*/

/*    class Solution {
        public int candy(int[] ratings) {
            int n = ratings.length;
            int[] left = new int[n];
            int[] right = new int[n];
            Arrays.fill(left, 1);
            Arrays.fill(right, 1);
            for (int i = 1; i < n; i++) {
                if (ratings[i] > ratings[i - 1]) {
                    left[i] = left[i - 1] + 1;
                }
            }
            int count = left[n - 1];
            for (int i = n - 2; i >= 0; i--) {
                if (ratings[i] > ratings[i + 1]) {
                    right[i] = right[i + 1] + 1;
                }
                count += Math.max(left[i], right[i]);
            }
            return count;
        }
    }*/

/*    class Solution {
        public long distributeCandies(int n, int limit) {
            long ans = 0;
            for (int left = 0; left <= limit; left++) {
                int l = Math.max(n - limit, left);
                int r = Math.min(left + limit, n);
                if (l <= r){
                    ans += r - l + 1;
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int snakesAndLadders(int[][] board) {
            int n = board.length;
            boolean[] vis = new boolean[n * n + 1];
            vis[1] = true;
            List<Integer> q = new ArrayList<>();
            q.add(1);
            for (int step = 0; !q.isEmpty(); step++) {
                List<Integer> tmp = q;
                q = new ArrayList<>();
                for (int x : tmp) {
                    if (x == n * n) {
                        return step;
                    }
                    for (int y = x + 1; y <= Math.min(x + 6, n * n); y++) {
                        int r = (y - 1) / n;
                        int c = (y - 1) % n;
                        if (r % 2 > 0) {
                            c = n - 1 - c;
                        }
                        int nxt = board[n - 1 - r][c];
                        if (nxt < 0) {
                            nxt = y;
                        }
                        if (!vis[nxt]) {
                            vis[nxt] = true;
                            q.add(nxt);
                        }
                    }
                }
            }
            return -1;
        }
    }*/

/*    class Solution {
        public int closestMeetingNode(int[] edges, int node1, int node2) {
            int[] dis1 = calcDis(edges, node1);
            int[] dis2 = calcDis(edges, node2);

            int n = edges.length;
            int minDis = n;
            int ans = -1;
            for (int i = 0; i < n; i++) {
                int d = Math.max(dis1[i], dis2[i]);
                if (d < minDis) {
                    minDis = d;
                    ans = i;
                }
            }
            return ans;
        }

        private int[] calcDis(int[] edges, int x) {
            int n = edges.length;
            int[] dis = new int[n];
            Arrays.fill(dis, n);
            for (int d = 0; x >= 0 && dis[x] == n; x = edges[x]) {
                dis[x] = d++;
            }
            return dis;
        }
    }*/


/*    class Solution {
        private List<Integer>[] buildTree(int[][] edges) {
            List<Integer>[] g = new ArrayList[edges.length + 1];
            Arrays.setAll(g, i -> new ArrayList<>());
            for (int[] e : edges) {
                int x = e[0];
                int y = e[1];
                g[x].add(y);
                g[y].add(x);
            }
            return g;
        }

        public int[] maxTargetNodes(int[][] edges1, int[][] edges2) {
            List<Integer>[] g2 = buildTree(edges2);
            int[] cnt2 = new int[2];
            dfs(0, -1, 0, g2, cnt2);
            int max2 = Math.max(cnt2[0], cnt2[1]);

            List<Integer>[] g1 = buildTree(edges1);
            int[] cnt1 = new int[2];
            dfs(0, -1, 0, g1, cnt1);

            int[] ans = new int[g1.length];
            Arrays.fill(ans, max2);
            dfs(0, -1, 0, g1, cnt1, ans);
            return ans;
        }

        private void dfs(int x, int fa, int d, List<Integer>[] g, int[] cnt) {
            cnt[d]++;
            for (int y : g[x]) {
                if (y != fa) {
                    dfs(y, x, d ^ 1, g, cnt);
                }
            }
        }

        private void dfs(int x, int fa, int d, List<Integer>[] g, int[] cnt, int[] ans) {
            ans[x] += cnt[d];
            for (int y : g[x]) {
                if (y != fa) {
                    dfs(y, x, d ^ 1, g, cnt, ans);
                }
            }
        }
    }*/


/*    class Solution {
        public int[] maxTargetNodes(int[][] edges1, int[][] edges2, int k) {
            int n = edges1.length + 1;
            int m = edges2.length + 1;
            int max2 = 0;
            if (k > 0) {
                List<Integer>[] g = new ArrayList[m];
                Arrays.setAll(g, i -> new ArrayList<>());
                for (int[] e : edges2) {
                    int x = e[0];
                    int y = e[1];
                    g[x].add(y);
                    g[y].add(x);
                }
                for (int i = 0; i < m; i++) {
                    max2 = Math.max(max2, dfs(i, -1, 0, g, k - 1));
                }
            }
            List<Integer>[] g = new ArrayList[n];
            Arrays.setAll(g, i -> new ArrayList<>());
            for (int[] e : edges1) {
                int x = e[0];
                int y = e[1];
                g[x].add(y);
                g[y].add(x);
            }
            int[] ans = new int[n];
            for (int i = 0; i < n; i++) {
                ans[i] = dfs(i, -1, 0, g, k) + max2;
            }
            return ans;
        }

        private int dfs(int x, int fa, int d, List<Integer>[] g, int k) {
            if (d > k) {
                return 0;
            }
            int cnt = 1;
            for (int y : g[x]) {
                if (y != fa) {
                    cnt += dfs(y, x, d + 1, g, k);
                }
            }
            return cnt;
        }
    }*/

/*    public static int solveGcd(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return solveGcd(b, a % b);
        }
    }

    public static void solveReverse(int n) {
        if (n < 10) {
            System.out.println(n);
        } else {
            System.out.print(n % 10);
            solveReverse(n / 10);
        }
    }

    public static double solveDis(int n, double h) {
        if (n == 1) {
            return h;
        } else {
            double pre = solveDis(n - 1, h / 2);
            return pre + h + h / 2;
        }
    }

    public static double solveHeight(int n, double h) {
        if (n == 0) {
            return h;
        } else {
            return solveHeight(n - 1, h / 2) / 2;
        }
    }

    public static int solveFn(int n, int f1, int a, int b) {
        if (n == 1) {
            return f1;
        } else {
            return a * solveFn(n - 1, f1, a, b) + b;
        }
    }

    public static int solveAge(int n) {
        if (n == 1) {
            return 10;
        } else {
            return solveAge(n - 1) + 2;
        }
    }*/


    /*class Solution {
        public int differenceOfSums(int n, int m) {
            int num1 = 0;
            int num2 = 0;
            for (int i = 1; i <= n; i++) {
                if (i % m == 0) {
                    num2 += i;
                } else {
                    num1 += i;
                }
            }
            return num1 - num2;
        }
    }*/

/*    public static void solveBubbleSort(int[] arr) {
        solveBubbleSort(arr, arr.length);
    }
    private static void solveBubbleSort(int[] arr, int n) {
        if (n <= 1) {
            return;
        }
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        solveBubbleSort(arr, n - 1);
    }

    private static void printArray(int[] arr) {
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

    public static void solveMulTable(int n) {
        if (n == 1) {
            System.out.println("1 * 1 = 1");
            return;
        }
        solveMulTable(n - 1);
        for (int i = 1; i <= n; i++) {
            System.out.printf("%d * %d = %d\t", i, n, n * i);
        }
        System.out.println();
    }

    public static int solveBs(int[] arr, int x, int left, int right) {
        if (left > right) {
            return -1;
        }
        int mid = left + (right - left) >>> 1;
        if (arr[mid] == x) {
            return mid;
        } else if (arr[mid] < x) {
            return solveBs(arr, x, mid + 1, right);
        } else {
            return solveBs(arr, x, left, mid - 1);
        }
    }

    public static int solveBs(int[] arr, int x) {
        return solveBs(arr, x, 0, arr.length - 1);
    }

    public static List<List<Integer>> solveMul(int n) {
        List<List<Integer>> ans = new ArrayList<>();
        fMul(n, 2, new ArrayList<>(), ans);
        return ans;
    }

    private static void fMul(int n, int start, List<Integer> path, List<List<Integer>> ans) {
        if (n == 1) {
            if (!path.isEmpty()) {
                ans.add(new ArrayList<>(path));
            }
            return;
        }
        for (int i = start; i <= n; i++) {
            if (n % i == 0) {
                path.add(i);
                fMul(n / i, i, path, ans);
                path.remove(path.size() - 1);
            }
        }
    }

    public static List<List<Integer>> solveAdd(int n) {
        List<List<Integer>> ans = new ArrayList<>();
        fAdd(n, n, new ArrayList<>(), ans);
        return ans;
    }

    private static void fAdd(int n, int max, List<Integer> current, List<List<Integer>> ans) {
        if (n == 0) {
            ans.add(new ArrayList<>(current));
            return;
        }
        for (int i = Math.min(max, n); i >= 1; i--) {
            current.add(i);
            fAdd(n - i, i, current, ans);
            current.remove(current.size() - 1);
        }
    }*/

/*    class Solution {
        public int largestPathValue(String colors, int[][] edges) {
            int n = colors.length();
            List<Integer>[] graph = new ArrayList[n];
            Arrays.setAll(graph, i -> new ArrayList<>());
            for (int[] e : edges) {
                int x = e[0];
                int y = e[1];
                if (x == y) {
                    return -1;
                }
                graph[x].add(y);
            }
            int ans = 0;
            char[] csArray = colors.toCharArray();
            int[][] dp = new int[n][];
            for (int x = 0; x < n; x++) {
                int[] res = dfs(x, graph, csArray, dp);
                if (res.length == 0) {
                    return -1;
                }
                ans = Math.max(ans, res[csArray[x] - 'a']);
            }
            return ans;
        }

        private int[] dfs(int x, List<Integer>[] graph, char[] colors, int[][] dp) {
            if (dp[x] != null) {
                return dp[x];
            }
            dp[x] = new int[]{};
            int[] res = new int[26];
            for (int y : graph[x]) {
                int[] cy = dfs(y, graph, colors, dp);
                if (cy.length == 0) {
                    return cy;
                }
                for (int i = 0; i < 26; i++) {
                    res[i] = Math.max(res[i], cy[i]);
                }
            }
            res[colors[x] - 'a']++;
            return dp[x] = res;
        }
    }*/

/*    class Solution {
        public static final int MAX_N = 26;

        public static int[][] cnt = new int[MAX_N][MAX_N];
        public void clear(){
            for (int i = 0; i < MAX_N; i++) {
                Arrays.fill(cnt[i], 0);
            }
        }

        public int longestPalindrome(String[] words) {
            clear();
            for (String w : words) {
                cnt[w.charAt(0) - 'a'][w.charAt(1) - 'a']++;
            }
            int ans = 0;
            int odd = 0;
            for (int i = 0; i < 26; i++) {
                int c = cnt[i][i];
                ans += c - c % 2;
                odd |= c % 2;
                for (int j = i + 1; j < 26; j++) {
                    ans += Math.min(cnt[i][j], cnt[j][i]) * 2;
                }
            }
            return (ans + odd) * 2;
        }
    }*/

   /* class Solution {
        public static Map<Character, List<Integer>> map = new HashMap<>();

        public int maxSubstrings(String word) {
            int n = word.length();
            if (n < 4){
                return 0;
            }
            map.clear();
            for (int i = 0; i < n; i++) {
                char c = word.charAt(i);
                map.computeIfAbsent(c, k -> new ArrayList<>()).add(i);
            }
            List<int[]> list = new ArrayList<>();
            for (int j = 3; j < n; j++) {
                char cur = word.charAt(j);
                List<Integer> pos = map.get(cur);
                if (pos == null){
                    continue;
                }
                int target = j - 3;
                int idx = Collections.binarySearch(pos, target);
                if (idx < 0) {
                    idx = -idx - 2;
                } else {
                    idx = Math.min(idx, pos.size() - 1);
                }
                while (idx >= 0) {
                    int i = pos.get(idx);
                    if (i <= j - 3) {
                        list.add(new int[]{i, j});
                        break;
                    }
                    idx--;
                }
            }
            list.sort((a, b) -> {
                if (a[1] != b[1]) {
                    return Integer.compare(a[1], b[1]);
                } else {
                    return Integer.compare(b[0], a[0]);
                }
            });
            int count = 0;
            int lastEnd = -1;
            for (int[] pair : list) {
                int start = pair[0];
                int end = pair[1];
                if (start > lastEnd) {
                    count++;
                    lastEnd = end;
                }
            }
            return count;
        }
    }*/

/*    class Solution {
        public static Map<Character, List<Integer>> map = new HashMap<>();
        public int maxSubstrings(String word) {
            int n = word.length();
            if (n < 4) {
                return 0;
            }
            map.clear();
            for (int i = 0; i < n; i++) {
                char c = word.charAt(i);
                map.computeIfAbsent(c, k -> new ArrayList<>()).add(i);
            }
            int count = 0;
            int start = 0;
            while (start <= n - 4) {
                char cur = word.charAt(start);
                List<Integer> pos = map.get(cur);
                if (pos == null) {
                    start++;
                    continue;
                }
                int target = start + 3;
                int idx = Collections.binarySearch(pos, target);
                if (idx < 0) {
                    idx = -idx - 1;
                }
                if (idx < pos.size()) {
                    int end = pos.get(idx);
                    if (end < n) {
                        count++;
                        start = end + 1;
                        continue;
                    }
                }
                start++;
            }
            return count;
        }
    }*/

/*    class Solution {
        public long sumOfLargestPrimes(String s) {
            Set<Long> st = new HashSet<>();
            int n = s.length();
            for (int i = 0; i < n; i++) {
                for (int j = i; j < n; j++) {
                    String substring = s.substring(i, j + 1);
                    long num =  Long.parseLong(substring);
                    if (num < 2) {
                        continue;
                    }
                    if (isPrime(num)) {
                        st.add(num);
                    }
                }
            }
            List<Long> list = new ArrayList<>(st);
            Collections.sort(list, Collections.reverseOrder());
            int sum = 0;
            int count = 0;
            for (Long p : list) {
                sum += p;
                count++;
                if (count == 3) {
                    break;
                }
            }
            return sum;
        }
        private boolean isPrime(long num) {
            if (num <= 1) {
                return false;
            }
            if (num == 2) {
                return true;
            }
            if (num % 2 == 0) {
                return false;
            }
            for (long i = 3; i <= num / i; i += 2) {
                if (num % i == 0) {
                    return false;
                }
            }
            return true;
        }
    }*/

/*    class Solution {
        public List<Integer> findWordsContaining(String[] words, char x) {
            List<Integer> ans = new ArrayList<>();
            for (int i = 0; i < words.length; i++) {
                String s = words[i];
                if (s.contains(String.valueOf(x))) {
                    ans.add(i);
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        public long maximumValueSum(int[] nums, int k, int[][] edges) {
            int n = nums.length;
            List<Integer>[] g = new ArrayList[n];
            Arrays.setAll(g, i -> new ArrayList<>());
            for (int[] e : edges) {
                int x = e[0];
                int y = e[1];
                g[x].add(y);
                g[y].add(x);
            }
            return dfs(0, -1, g, nums, k)[0];
        }

        private long[] dfs(int x, int fa, List<Integer>[] g, int[] nums, int k) {
            long f0 = 0;
            long f1 = Long.MIN_VALUE;
            for (int y : g[x]) {
                if (y != fa) {
                    long[] r = dfs(y, x, g, nums, k);
                    long t = Math.max(f1 + r[0], f0 + r[1]);
                    f0 = Math.max(f0 + r[0], f1 + r[1]);
                    f1 = t;
                }
            }
            return new long[]{Math.max(f0 + nums[x], f1 + (nums[x] ^ k)),
                    Math.max(f1 + nums[x], f0 + (nums[x] ^ k))};
        }
    }*/

/*    class Solution {
        public int maxRemoval(int[] nums, int[][] queries) {
            Arrays.sort(queries, (a, b) -> a[0] - b[0]);
            PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
            int n = nums.length;
            int[] diff = new int[n + 1];
            int sum = 0;
            int j = 0;
            for (int i = 0; i < n; i++) {
                sum += diff[i];
                while (j < queries.length && queries[j][0] <= i) {
                    pq.add(queries[j][1]);
                    j++;
                }
                while (sum < nums[i] && !pq.isEmpty() && pq.peek() >= i) {
                    sum++;
                    diff[pq.poll() + 1]--;
                }
                if (sum < nums[i]) {
                    return -1;
                }
            }
            return pq.size();
        }
    }*/

/*    class Solution {
        public static int MAX_N = 100005;

        public static long[] arr = new long[MAX_N];

        public static long[] max = new long[MAX_N << 2];

        public static long[] add = new long[MAX_N << 2];

        public static void up(int i) {
            max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
        }

        public static void lazy(int i, long v) {
            max[i] += v;
            add[i] += v;
        }

        public static void down(int i) {
            if (add[i] != 0) {
                lazy(i << 1, add[i]);
                lazy(i << 1 | 1, add[i]);
                add[i] = 0;
            }
        }

        public static void build(int l, int r, int i) {
            if (l == r) {
                max[i] = arr[l];
            } else {
                int mid = (l + r) >> 1;
                build(l, mid, i << 1);
                build(mid + 1, r, i << 1 | 1);
                up(i);
            }
            add[i] = 0;
        }

        public static void add(int jobl, int jobr, long jobv, int l, int r, int i) {
            if (jobl <= l && r <= jobr) {
                lazy(i, jobv);
            } else {
                int mid = (l + r) >> 1;
                down(i);
                if (jobl <= mid) {
                    add(jobl, jobr, jobv, l, mid, i << 1);
                }
                if (jobr > mid) {
                    add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
                }
                up(i);
            }
        }

        public static long query(int jobl, int jobr, int l, int r, int i) {
            if (jobl <= l && r <= jobr)
                return max[i];
            int mid = (l + r) >> 1;
            down(i);
            long ans = Long.MIN_VALUE;
            if (jobl <= mid)
                ans = Math.max(ans, query(jobl, jobr, l, mid, i << 1));
            if (jobr > mid)
                ans = Math.max(ans, query(jobl, jobr, mid + 1, r, (i << 1) + 1));
            return ans;
        }

        public int minZeroArray(int[] nums, int[][] queries) {
            int n = nums.length;
            for (int i = 1; i <= n; i++) {
                arr[i] = nums[i - 1];
            }
            build(1, n, 1);
            if (max[1] == 0)
                return 0;
            int k = 0;
            for (int i = 0; i < queries.length; i++) {
                int l = queries[i][0] + 1;
                int r = queries[i][1] + 1;
                int v = queries[i][2];
                add(l, r, -v, 1, n, 1);
                if (query(1, n, 1, n, 1) <= 0) {
                    return i + 1;
                }
            }
            return -1;
        }
    }*/

/*    class Solution {
        public static int MAX_N = 100005;

        public static long[] arr = new long[MAX_N];

        public static long[] max = new long[MAX_N << 2];

        public static long[] add = new long[MAX_N << 2];

        public static void up(int i) {
            max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
        }

        public static void lazy(int i, long v) {
            max[i] += v;
            add[i] += v;
        }

        public static void down(int i) {
            if (add[i] != 0) {
                lazy(i << 1, add[i]);
                lazy(i << 1 | 1, add[i]);
                add[i] = 0;
            }
        }

        public static void build(int l, int r, int i) {
            if (l == r) {
                max[i] = arr[l];
            } else {
                int mid = (l + r) >> 1;
                build(l, mid, i << 1);
                build(mid + 1, r, i << 1 | 1);
                up(i);
            }
            add[i] = 0;
        }

        public static void add(int jobl, int jobr, long jobv, int l, int r, int i) {
            if (jobl <= l && r <= jobr) {
                lazy(i, jobv);
            } else {
                int mid = (l + r) >> 1;
                down(i);
                if (jobl <= mid) {
                    add(jobl, jobr, jobv, l, mid, i << 1);
                }
                if (jobr > mid) {
                    add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
                }
                up(i);
            }
        }

        public static long query(int jobl, int jobr, int l, int r, int i) {
            if (jobl <= l && r <= jobr)
                return max[i];
            int mid = (l + r) >> 1;
            down(i);
            long ans = Long.MIN_VALUE;
            if (jobl <= mid)
                ans = Math.max(ans, query(jobl, jobr, l, mid, i << 1));
            if (jobr > mid)
                ans = Math.max(ans, query(jobl, jobr, mid + 1, r, (i << 1) + 1));
            return ans;
        }

        public boolean isZeroArray(int[] nums, int[][] queries) {
            int n = nums.length;
            for (int i = 1; i <= n; i++) {
                arr[i] = nums[i - 1];
            }
            build(1, n, 1);
            for (int i = 0; i < queries.length; i++) {
                int l = queries[i][0] + 1;
                int r = queries[i][1] + 1;
                add(l, r, -1, 1, n, 1);
                if (query(1, n, 1, n, 1) <= 0) {
                    return true;
                }
            }
            return false;
        }
    }*/

/*    class Solution {
        public String triangleType(int[] nums) {
            int a = nums[0];
            int b = nums[1];
            int c = nums[2];
            if (a + b <= c || a + c <= b || b + c <= a) {
                return "none";
            }
            if (a == b && a == c && b == c) {
                return "equilateral";
            }
            if ((a == b && a != c) || (b == c && a != b) | (a == c && a != b)) {
                return "isosceles";
            }
            if (a != b && a != c && b != c) {
                return "scalene";
            }
            return "111";
        }
    }*/


/*    class Solution {
        public int minMoves(String[] matrix) {
            int m = matrix.length;
            if (m == 0) {
                return -1;
            }
            int n = matrix[0].length();
            if (matrix[0].charAt(0) == '#' || matrix[m-1].charAt(n-1) == '#') {
                return -1;
            }

            Map<Character, List<int[]>> portals = new HashMap<>();
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    char c = matrix[i].charAt(j);
                    if (Character.isUpperCase(c)) {
                        portals.computeIfAbsent(c, k -> new ArrayList<>()).add(new int[]{i, j});
                    }
                }
            }

            Queue<int[]> queue = new LinkedList<>();
            Set<String> visited = new HashSet<>();
            queue.add(new int[]{0, 0, 0, 0});
            visited.add(encode(0, 0, 0));
            int[][] dirs = {{-1,0}, {1,0}, {0,-1}, {0,1}};
            while (!queue.isEmpty()) {
                int[] curr = queue.poll();
                int x = curr[0], y = curr[1], mask = curr[2], steps = curr[3];
                if (x == m-1 && y == n-1) {
                    return steps;
                }
                if (Character.isUpperCase(matrix[x].charAt(y))) {
                    char portal = matrix[x].charAt(y);
                    int bit = 1 << (portal - 'A');
                    if ((mask & bit) == 0) {
                        for (int[] pos : portals.get(portal)) {
                            int tx = pos[0], ty = pos[1];
                            if (tx == x && ty == y) {
                                continue; // 跳过自身
                            }
                            String key = encode(tx, ty, mask | bit);
                            if (isValid(tx, ty, matrix) && !visited.contains(key)) {
                                visited.add(key);
                                queue.add(new int[]{tx, ty, mask | bit, steps});
                            }
                        }
                    }
                }

                // 处理普通移动
                for (int[] dir : dirs) {
                    int nx = x + dir[0], ny = y + dir[1];
                    if (isValid(nx, ny, matrix)) {
                        String key = encode(nx, ny, mask);
                        if (!visited.contains(key)) {
                            visited.add(key);
                            queue.add(new int[]{nx, ny, mask, steps + 1});
                        }
                    }
                }
            }
            return -1;
        }

        private String encode(int x, int y, int mask) {
            return x + "," + y + "," + mask;
        }

        private boolean isValid(int x, int y, String[] matrix) {
            return x >= 0 && x < matrix.length && y >= 0 && y < matrix[0].length()
                    && matrix[x].charAt(y) != '#';
        }
    }*/


/*    class Solution {
        private static final int LOG = 20;
        private int[][] up;
        private int[] depth;
        private int[] distRoot;
        private int[][] distUp;

        public int[] minimumWeight(int[][] edges, int[][] queries) {
            int n = edges.length + 1;
            List<List<int[]>> adj = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                adj.add(new ArrayList<>());
            }
            for (int[] edge : edges) {
                int u = edge[0], v = edge[1], w = edge[2];
                adj.get(u).add(new int[]{v, w});
                adj.get(v).add(new int[]{u, w});
            }
            up = new int[LOG][n];
            distUp = new int[LOG][n];
            depth = new int[n];
            distRoot = new int[n];
            for (int i = 0; i < LOG; i++) {
                Arrays.fill(up[i], -1);
                Arrays.fill(distUp[i], 0);
            }
            Arrays.fill(depth, -1);
            Arrays.fill(distRoot, -1);

            dfs(0, -1, 0, 0, adj);

            for (int k = 1; k < LOG; k++) {
                for (int u = 0; u < n; u++) {
                    int prev = up[k - 1][u];
                    if (prev != -1) {
                        up[k][u] = up[k - 1][prev];
                        distUp[k][u] = distUp[k - 1][u] + distUp[k - 1][prev];
                    } else {
                        up[k][u] = -1;
                        distUp[k][u] = 0;
                    }
                }
            }

            int[] answer = new int[queries.length];
            for (int i = 0; i < queries.length; i++) {
                int src1 = queries[i][0], src2 = queries[i][1], dest = queries[i][2];
                int a = getDistance(src1, dest);
                int b = getDistance(src2, dest);
                int c = getDistance(src1, src2);
                answer[i] = (a + b + c) / 2;
            }
            return answer;
        }

        private void dfs(int u, int parent, int currentDepth, int currentDist, List<List<int[]>> adj) {
            up[0][u] = parent;
            depth[u] = currentDepth;
            distRoot[u] = currentDist;
            for (int[] neighbor : adj.get(u)) {
                int v = neighbor[0], w = neighbor[1];
                if (v != parent) {
                    distUp[0][v] = w;
                    dfs(v, u, currentDepth + 1, currentDist + w, adj);
                }
            }
        }

        private int getLCA(int u, int v) {
            if (depth[u] < depth[v]) {
                int temp = u;
                u = v;
                v = temp;
            }
            for (int k = LOG - 1; k >= 0; k--) {
                if (depth[u] - (1 << k) >= depth[v]) {
                    u = up[k][u];
                }
            }
            if (u == v) return u;
            for (int k = LOG - 1; k >= 0; k--) {
                if (up[k][u] != up[k][v]) {
                    u = up[k][u];
                    v = up[k][v];
                }
            }
            return up[0][u];
        }

        private int getDistance(int u, int v) {
            int lca = getLCA(u, v);
            return distRoot[u] + distRoot[v] - 2 * distRoot[lca];
        }
    }*/

/*    class Solution {
        public int minMoves(String[] matrix) {
            int m = matrix.length;
            if (m == 0) {
                return -1;
            }
            int n = matrix[0].length();
            if (matrix[0].charAt(0) == '#' || matrix[m-1].charAt(n-1) == '#') {
                return -1;
            }
            Map<Character, List<int[]>> portalMap = new HashMap<>();
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    char c = matrix[i].charAt(j);
                    if (Character.isUpperCase(c)) {
                        portalMap.computeIfAbsent(c, k -> new ArrayList<>()).add(new int[]{i, j});
                    }
                }
            }
            Queue<int[]> queue = new LinkedList<>();
            Set<String> visited = new HashSet<>();
            queue.add(new int[]{0, 0, 0, 0});
            visited.add(0 + "," + 0 + "," + 0);
            int[][] dirs = {{-1,0}, {1,0}, {0,-1}, {0,1}};
            while (!queue.isEmpty()) {
                int[] curr = queue.poll();
                int x = curr[0], y = curr[1], mask = curr[2], steps = curr[3];
                if (x == m-1 && y == n-1) return steps;
                if (Character.isUpperCase(matrix[x].charAt(y))) {
                    char portal = matrix[x].charAt(y);
                    int portalBit = 1 << (portal - 'A');
                    if ((mask & portalBit) == 0) {
                        List<int[]> portals = portalMap.get(portal);
                        if (portals != null) {
                            for (int[] pos : portals) {
                                int tx = pos[0], ty = pos[1];
                                if (tx == x && ty == y) continue;

                                String key = tx + "," + ty + "," + (mask | portalBit);
                                if (isValid(tx, ty, matrix) && !visited.contains(key)) {
                                    visited.add(key);
                                    queue.add(new int[]{tx, ty, mask | portalBit, steps});
                                }
                            }
                        }
                    }
                }

                *//* 处理四个方向移动（步数+1） *//*
                for (int[] dir : dirs) {
                    int nx = x + dir[0], ny = y + dir[1];
                    String key = nx + "," + ny + "," + mask;
                    if (isValid(nx, ny, matrix) && !visited.contains(key)) {
                        visited.add(key);
                        queue.add(new int[]{nx, ny, mask, steps + 1});
                    }
                }
            }
            return -1;
        }

        private boolean isValid(int x, int y, String[] matrix) {
            return x >= 0 && x < matrix.length && y >= 0 && y < matrix[0].length()
                    && matrix[x].charAt(y) != '#';
        }
    }*/

/*    class Solution {

        public static final int MAX_N = 100010;

        public static List<Integer> list = new ArrayList<>();

        public static Map<Integer, Integer> map = new HashMap<>();

        public static boolean[] vis = new boolean[MAX_N];

        public  void clear(int n){
            list.clear();
            map.clear();
            for(int i =0;i<n;i++){
                vis[i] = false;
            }
        }
        public int minSwaps(int[] nums) {
            int n = nums.length;
            clear(n);
            for (int num : nums) {
                list.add(num);
            }
            Collections.sort(list, (a, b) -> {
                if (getSum(a) == getSum(b)) {
                    return a.compareTo(b);
                } else {
                    return getSum(a) - getSum(b);
                }
            });
            for (int i = 0; i < n; i++) {
                map.put(list.get(i), i);
            }
            int ans = 0;
            for (int i = 0; i < n; i++) {
                if (!vis[i]) {
                    int cirSize = 0;
                    int j = i;
                    while (!vis[j]) {
                        vis[j] = true;
                        j = map.get(nums[j]);
                        cirSize++;
                    }
                    ans += (cirSize - 1);
                }
            }
            return ans;
        }

        private int getSum(int x) {
            int sum = 0;
            while (x > 0) {
                sum += x % 10;
                x /= 10;
            }
            return sum;
        }
    }*/

/*    class Solution {
        private static final int MOD = 1_000_000_007;

        public int colorTheGrid(int m, int n) {
            int[] pow3 = new int[m];
            pow3[0] = 1;
            for (int i = 1; i < m; i++) {
                pow3[i] = pow3[i - 1] * 3;
            }

            List<Integer> valid = new ArrayList<>();
            next:
            for (int color = 0; color < pow3[m - 1] * 3; color++) {
                for (int i = 1; i < m; i++) {
                    if (color / pow3[i] % 3 == color / pow3[i - 1] % 3) { // 相邻颜色相同
                        continue next;
                    }
                }
                valid.add(color);
            }

            int nv = valid.size();
            List<Integer>[] nxt = new ArrayList[nv];
            Arrays.setAll(nxt, i -> new ArrayList<>());
            for (int i = 0; i < nv; i++) {
                next2:
                for (int j = 0; j < nv; j++) {
                    for (int p3 : pow3) {
                        if (valid.get(i) / p3 % 3 == valid.get(j) / p3 % 3) { // 相邻颜色相同
                            continue next2;
                        }
                    }
                    nxt[i].add(j);
                }
            }
            int[][] dp = new int[n][nv];
            for (int[] row : dp) {
                Arrays.fill(row, -1);
            }
            long ans = 0;
            for (int j = 0; j < nv; j++) {
                ans += dfs(n - 1, j, nxt, dp);
            }
            return (int) (ans % MOD);
        }

        private int dfs(int i, int j, List<Integer>[] nxt, int[][] dp) {
            if (i == 0) {
                return 1;
            }
            if (dp[i][j] != -1) {
                return dp[i][j];
            }
            long res = 0;
            for (int k : nxt[j]) {
                res += dfs(i - 1, k, nxt, dp);
            }
            return dp[i][j] = (int) (res % MOD);
        }
    }*/

/*    class Solution {
        public int[][] merge(int[][] intervals) {
            Arrays.sort(intervals, (x, y) -> x[0] - y[0]);
            int n = intervals.length;
            int preEnd = intervals[0][1];
            int preIndex = 0;
            ArrayList<int[]> ans = new ArrayList<>();
            for (int i = 1; i < n; i++) {
                if (intervals[i][0] <= preEnd) {
                    preEnd = Math.max(preEnd, intervals[i][1]);
                } else {
                    ans.add(new int[]{intervals[preIndex][0], preEnd});
                    preEnd = intervals[i][1];
                    preIndex = i;
                }
            }
            return ans.toArray(new int[ans.size()][2]);
        }
    }*/

/*    class Solution {
        public void sortColors(int[] nums) {
            int red = 0;
            int white = 0;
            int blue = 0;
            for (int x : nums) {
                if (x == 0) {
                    red++;
                } else if (x == 1) {
                    white++;
                } else {
                    blue++;
                }
            }
            for (int i = 0; i < nums.length; i++) {
                if (i < red) {
                    nums[i] = 0;
                } else if (i < red + white) {
                    nums[i] = 1;
                } else if (i < red + white + blue) {
                    nums[i] = 2;
                }
            }
        }
    }*/

/*    class Solution {
        public static final int MAX_N =1000;

        public static int[] dp = new int[MAX_N];

        public static int[] pre = new int[MAX_N];

        public void clear(int n){
            for (int i = 0; i < n; i++) {
                dp[i] = 0;
                pre[i] = 0;
            }
        }

        public List<String> getWordsInLongestSubsequence(String[] words, int[] groups) {
            int n = words.length;
            clear(n);
            int maxI = n - 1;
            for (int i = n - 1; i >= 0; i--) {
                for (int j = i + 1; j < n; j++) {
                    if (dp[j] > dp[i] && groups[j] != groups[i] && check(words[i], words[j])) {
                        dp[i] = dp[j];
                        pre[i] = j;
                    }
                }
                dp[i]++;
                if (dp[i] > dp[maxI]) {
                    maxI = i;
                }
            }
            int i = maxI;
            int m = dp[i];
            List<String> ans = new ArrayList<>(m);
            for (int k = 0; k < m; k++) {
                ans.add(words[i]);
                i = pre[i];
            }
            return ans;
        }

        private boolean check(String s, String t) {
            if (s.length() != t.length()) {
                return false;
            }
            boolean diff = false;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) != t.charAt(i)) {
                    if (diff) {
                        return false;
                    }
                    diff = true;
                }
            }
            return diff;
        }
    }*/

/*    class Solution {
        public List<String> getLongestSubsequence(String[] words, int[] groups) {
            int lastOp = -1;
            List<String> ans = new ArrayList<>();
            for (int i = 0; i < groups.length; i++) {
                if (groups[i] != lastOp) {
                    ans.add(words[i]);
                    lastOp = groups[i];
                }
            }
            return ans;
        }
    }*/

    /*class Solution {
        private static final int MOD = 1_000_000_007;

        public static final int SIZE = 26;

        public int lengthAfterTransformations(String s, int t, List<Integer> nums) {
            int[][] f0 = new int[SIZE][1];
            for (int i = 0; i < SIZE; i++) {
                f0[i][0] = 1;
            }
            int[][] m = new int[SIZE][SIZE];
            for (int i = 0; i < SIZE; i++) {
                int c = nums.get(i);
                for (int j = i + 1; j <= i + c; j++) {
                    m[i][j % SIZE] = 1;
                }
            }
            int[][] mt = powMul(m, t, f0);
            int[] cnt = new int[SIZE];
            for (char c : s.toCharArray()) {
                cnt[c - 'a']++;
            }
            long ans = 0;
            for (int i = 0; i < SIZE; i++) {
                ans += (long) mt[i][0] * cnt[i];
            }
            return (int) (ans % MOD);
        }

        private int[][] powMul(int[][] a, int n, int[][] f0) {
            int[][] res = f0;
            while (n > 0) {
                if ((n & 1) > 0) {
                    res = mul(a, res);
                }
                a = mul(a, a);
                n >>= 1;
            }
            return res;
        }

        private int[][] mul(int[][] a, int[][] b) {
            int[][] c = new int[a.length][b[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int k = 0; k < a[i].length; k++) {
                    if (a[i][k] == 0) {
                        continue;
                    }
                    for (int j = 0; j < b[k].length; j++) {
                        c[i][j] = (int) ((c[i][j] + (long) a[i][k] * b[k][j]) % MOD);
                    }
                }
            }
            return c;
        }
    }*/

/*    class Solution {
        private static final int MOD = 1000000007;

        public int lengthAfterTransformations(String s, int t) {
            long ans = 0;
            int n = s.length();
            int[][] dp = new int[27][t + 1];
            for (int i = 0; i < 27; i++) {
                Arrays.fill(dp[i], -1);
            }
            for (char c : s.toCharArray()) {
                if (t <= 0) {
                    break;
                }
                ans += dfs(dp, c, t);
                ans %= MOD;
            }
            return (int) ans + s.length();
        }

        private int dfs(int[][] dp, char c, int t) {
            if (t <= 0) {
                return 0;
            }
            if (dp[c - 'a'][t] != -1) {
                return dp[c - 'a'][t];
            }
            int ans = 0;
            if (c == 'z') {
                ans += 1 + dfs(dp, 'a', t - 1) + dfs(dp, 'b', t - 1);
                ans %= MOD;
            } else {
                ans += dfs(dp, (char) (c + 1), t - 1);
                ans %= MOD;
            }
            dp[c - 'a'][t] = ans;
            return ans;
        }
    }*/


/*    class Solution {
        public int[] findEvenNumbers(int[] digits) {
            int[] cnt = new int[10];
            for (int d : digits) {
                cnt[d]++;
            }
            List<Integer> ans = new ArrayList<>();
            boolean flag = true;
            for (int i = 100; i < 1000; i += 2) {
                int[] c = new int[10];
                flag = true;
                for (int x = i; x > 0; x /= 10) {
                    int d = x % 10;
                    if (++c[d] > cnt[d]) {
                        flag = false;
                    }
                }
                if (flag == true) {
                    ans.add(i);
                }
            }
            return ans.stream().mapToInt(i -> i).toArray();
        }
    }*/

/*    class Solution {
        public boolean threeConsecutiveOdds(int[] arr) {
            int n = arr.length;
            for (int i = 1; i < n - 1; i++) {
                if (arr[i - 1] % 2 != 0 && arr[i] % 2 != 0 && arr[i + 1] % 2 != 0) {
                    return true;
                }
            }
            return false;
        }
    }*/

/*    class Solution {

        class Pair{
            long sum;
            boolean zero;

            public Pair(long sum,boolean zero){
                this.sum = sum;
                this.zero = zero;
            }
        }

        public long minSum(int[] nums1, int[] nums2) {
            Pair p1 = calc(nums1);
            Pair p2 = calc(nums2);
            if (!p1.zero && p1.sum < p2.sum || !p2.zero && p2.sum < p1.sum) {
                return -1;
            }
            return Math.max(p1.sum, p2.sum);
        }

        private Pair calc(int[] nums) {
            long sum = 0;
            boolean zero = false;
            for (int x : nums) {
                if (x == 0) {
                    zero = true;
                    sum++;
                } else {
                    sum += x;
                }
            }
            return new Pair(sum, zero);
        }
    }*/


    /*class Solution {
        private static final int MOD = 1_000_000_007;
        private static final int MX = 41;

        private static final long[] F = new long[MX];
        private static final long[] INV_F = new long[MX];

        static {
            F[0] = 1;
            for (int i = 1; i < MX; i++) {
                F[i] = F[i - 1] * i % MOD;
            }
            INV_F[MX - 1] = pow(F[MX - 1], MOD - 2);
            for (int i = MX - 1; i > 0; i--) {
                INV_F[i - 1] = INV_F[i] * i % MOD;
            }
        }

        public int countBalancedPermutations(String num) {
            int[] cnt = new int[10];
            int total = 0;
            for (char c : num.toCharArray()) {
                cnt[c - '0']++;
                total += c - '0';
            }

            if (total % 2 > 0) {
                return 0;
            }

            for (int i = 1; i < 10; i++) {
                cnt[i] += cnt[i - 1];
            }

            int n = num.length();
            int n1 = n / 2;
            int[][][] memo = new int[10][n1 + 1][total / 2 + 1];
            for (int[][] mat : memo) {
                for (int[] row : mat) {
                    Arrays.fill(row, -1);
                }
            }
            return (int) (F[n1] * F[n - n1] % MOD * dfs(9, n1, total / 2, cnt, memo) % MOD);
        }

        private int dfs(int i, int left1, int leftS, int[] cnt, int[][][] memo) {
            if (i < 0) {
                return leftS == 0 ? 1 : 0;
            }
            if (memo[i][left1][leftS] != -1) {
                return memo[i][left1][leftS];
            }
            long res = 0;
            int c = cnt[i] - (i > 0 ? cnt[i - 1] : 0);
            int left2 = cnt[i] - left1;
            for (int k = Math.max(c - left2, 0); k <= Math.min(c, left1) && k * i <= leftS; k++) {
                long r = dfs(i - 1, left1 - k, leftS - k * i, cnt, memo);
                res = (res + r * INV_F[k] % MOD * INV_F[c - k]) % MOD;
            }
            return memo[i][left1][leftS] = (int) res;
        }

        private static long pow(long x, int n) {
            long res = 1;
            for (; n > 0; n /= 2) {
                if (n % 2 > 0) {
                    res = res * x % MOD;
                }
                x = x * x % MOD;
            }
            return res;
        }
    }*/

    /*class Solution {
        private final static int[][] move = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        public int minTimeToReach(int[][] moveTime) {
            int n = moveTime.length;
            int m = moveTime[0].length;

            int[][] dis = new int[n][m];
            for (int[] row : dis) {
                Arrays.fill(row, Integer.MAX_VALUE);
            }
            dis[0][0] = 0;

            PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
            pq.add(new int[]{0, 0, 0});

            while (true) {
                int[] p = pq.poll();
                int d = p[0];
                int x = p[1];
                int y = p[2];
                if (x == n - 1 && y == m - 1) {
                    return d;
                }
                if (d > dis[x][y]) {
                    continue;
                }
                int time = (x + y) % 2 + 1;
                for (int[] q : move) {
                    int nx = x + q[0];
                    int ny = y + q[1];
                    if (0 <= nx && nx < n && 0 <= ny && ny < m) {
                        int newDis = Math.max(d, moveTime[nx][ny]) + time;
                        if (newDis < dis[nx][ny]) {
                            dis[nx][ny] = newDis;
                            pq.add(new int[]{newDis, nx, ny});
                        }
                    }
                }
            }
        }
    }*/

/*    class Solution {
        public static int[] move = new int[] { -1, 0, 1, 0, -1 };

        public int minTimeToReach(int[][] moveTime) {
            int n = moveTime.length;
            int m = moveTime[0].length;
            return djk(moveTime, 0, 0, n - 1, m - 1);
        }

        public static int djk(int[][] grid, int startX, int startY, int targetX, int targetY) {
            int n = grid.length;
            int m = grid[0].length;
            int[][] distance = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    distance[i][j] = Integer.MAX_VALUE;
                }
            }
            distance[startX][startY] = 0;
            boolean[][] visited = new boolean[n][m];
            PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[2] - b[2]);
            heap.add(new int[] { startX, startY, 0 });
            while (!heap.isEmpty()) {
                int[] cur = heap.poll();
                int x = cur[0];
                int y = cur[1];
                if (visited[x][y]) {
                    continue;
                }
                visited[x][y] = true;
                if (x == targetX && y == targetY) {
                    return distance[x][y];
                }
                for (int i = 0, nx, ny; i < 4; i++) {
                    nx = x + move[i];
                    ny = y + move[i + 1];
                    if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]
                            && (distance[x][y] < grid[nx][ny] ? grid[nx][ny] + 1 : distance[x][y] + 1) < distance[nx][ny]) {
                        distance[nx][ny] = distance[x][y] < grid[nx][ny] ? grid[nx][ny] + 1 : distance[x][y] + 1;
                        heap.add(new int[] { nx, ny, distance[nx][ny] });
                    }
                }
            }
            return -1;
        }
    }*/

/*    class Solution {
        public int[] buildArray(int[] nums) {
            int n = nums.length;
            int[] ans = new int[n];
            for (int i = 0; i < n; i++) {
                ans[i] = nums[nums[i]];
            }
            return ans;
        }
    }*/

/*    class Solution {
        public static int numTilings(int n) {
            return f(n - 1);
        }

        public static int MOD = 1000000007;

        public static int f(int n) {
            if (n == 0) {
                return 1;
            }
            if (n == 1) {
                return 2;
            }
            if (n == 2) {
                return 5;
            }
            int[][] start = { { 5, 2, 1 } };
            int[][] base = {
                    { 2, 1, 0 },
                    { 0, 0, 1 },
                    { 1, 0, 0 }
            };
            int[][] ans = multiply(start, power(base, n - 2));
            return ans[0][0];
        }

        public static int[][] multiply(int[][] a, int[][] b) {
            int n = a.length;
            int m = b[0].length;
            int k = a[0].length;
            int[][] ans = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    for (int c = 0; c < k; c++) {
                        ans[i][j] = (int) (((long) a[i][c] * b[c][j] + ans[i][j]) % MOD);
                    }
                }
            }
            return ans;
        }

        public static int[][] power(int[][] m, int p) {
            int n = m.length;
            int[][] ans = new int[n][n];
            for (int i = 0; i < n; i++) {
                ans[i][i] = 1;
            }
            for (; p != 0; p >>= 1) {
                if ((p & 1) != 0) {
                    ans = multiply(ans, m);
                }
                m = multiply(m, m);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public static int MAX_N = 10;

        public static int[][] cnt = new int[MAX_N][MAX_N];

        public void clear() {
            for (int i = 0; i < MAX_N; i++) {
                Arrays.fill(cnt[i], 0);
            }
        }

        public int numEquivDominoPairs(int[][] dominoes) {
            int ans = 0;
            int[][] cnt = new int[10][10];
            for (int[] d : dominoes) {
                int a = Math.min(d[0], d[1]);
                int b = Math.max(d[0], d[1]);
                ans += cnt[a][b]++;
            }
            return ans;
        }
    }*/


/*    class Solution {
        public String pushDominoes(String dominoes) {
            char[] s = ("L" + dominoes + "R").toCharArray();
            int pre = 0;
            int n = s.length;
            for (int i = 1; i < n; i++) {
                if (s[i] == '.') {
                    continue;
                }
                if (s[i] == s[pre]) {
                    Arrays.fill(s, pre + 1, i, s[i]);
                } else if (s[i] == 'L') {
                    Arrays.fill(s, pre + 1, (pre + i - 1) / 2 + 1, 'R');
                    Arrays.fill(s, (pre + i) / 2 + 1, i, 'L');
                }
                pre = i;
            }
            return new String(s, 1, n - 2);
        }
    }*/

    /*class Solution {
        public static int[] tasks;

        public static int[] workers;

        public static int MAXN = 50001;

        public static int[] deque = new int[MAXN];

        public static int h, t;

        public static int maxTaskAssign(int[] ts, int[] ws, int pills, int strength) {
            tasks = ts;
            workers = ws;
            Arrays.sort(tasks);
            Arrays.sort(workers);
            int tsize = tasks.length;
            int wsize = workers.length;
            int ans = 0;
            for (int l = 0, r = Math.min(tsize, wsize), m; l <= r;) {
                m = (l + r) / 2;
                if (f(0, m - 1, wsize - m, wsize - 1, strength, pills)) {
                    ans = m;
                    l = m + 1;
                } else {
                    r = m - 1;
                }
            }
            return ans;
        }

        public static boolean f(int tl, int tr, int wl, int wr, int s, int pills) {
            h = t = 0;
            int cnt = 0;
            for (int i = wl, j = tl; i <= wr; i++) {
                for (; j <= tr && tasks[j] <= workers[i]; j++) {
                    deque[t++] = j;
                }
                if (h < t && tasks[deque[h]] <= workers[i]) {
                    h++;
                } else {
                    for (; j <= tr && tasks[j] <= workers[i] + s; j++) {
                        deque[t++] = j;
                    }
                    if (h < t) {
                        cnt++;
                        t--;
                    } else {
                        return false;
                    }
                }
            }
            return cnt <= pills;
        }
    }*/

/*    class Solution {
        public int findNumbers(int[] nums) {
            int n = nums.length;
            int ans = 0;
            for (int i = 0; i < n; i++) {
                if (getCnt(nums[i]) % 2 == 0) {
                    ans++;
                }
            }
            return ans;
        }

        public int getCnt(int x) {
            int cnt = 0;
            while (x > 0) {
                cnt++;
                x /= 10;
            }
            return cnt;
        }
    }*/


    /*class Solution {
        public long countSubarrays(int[] nums, int k) {
            int n = nums.length;
            int maxVal = 0;
            for (int x : nums) {
                maxVal = Math.max(maxVal, x);
            }
            long ans = 0;
            int cnt = 0;
            int left = 0;
            for (int right = 0, x; right < n; right++) {
                x = nums[right];
                if (x == maxVal) {
                    cnt++;
                }
                while (cnt == k) {
                    if (nums[left] == maxVal) {
                        cnt--;
                    }
                    left++;
                }
                ans += left;
            }
            return ans;
        }
    }*/

/*    class Solution {
        public long countSubarrays(int[] nums, long k) {
            int n = nums.length;
            long ans = 0;
            long sum = 0;
            int left = 0;
            for (int right = 0; right < n; right++) {
                sum += nums[right];
                while (sum * (right - left + 1) >= k) {
                    sum -= nums[left];
                    left++;
                }
                ans += right - left + 1;
            }
            return ans;
        }
    }*/


/*    class Solution {
        public int countSubarrays(int[] nums) {
            int n = nums.length;
            int cnt = 0;
            for (int i = 1, left, mid, right; i < n - 1; i++) {
                left = nums[i - 1];
                mid = nums[i];
                right = nums[i + 1];
                if ((left + right) * 2 == mid) {
                    cnt++;
                }
            }
            return cnt;
        }
    }*/

/*    class Solution {
        public long countSubarrays(int[] nums, int minK, int maxK) {
            long ans = 0;
            int minIndex = -1;
            int maxIndex = -1;
            int index = -1;
            for (int i = 0; i < nums.length; i++) {
                int x = nums[i];
                if (x == minK) {
                    minIndex = i;
                }
                if (x == maxK) {
                    maxIndex = i;
                }
                if (x < minK || x > maxK) {
                    index = i;
                }
                ans += Math.max(Math.min(minIndex, maxIndex) - index, 0);
            }
            return ans;
        }
    }*/


/*    class Solution {
        public long countInterestingSubarrays(List<Integer> nums, int modulo, int k) {
            int n = nums.size();
            int[] preSum = new int[n + 1];
            for (int i = 0; i < n; i++) {
                preSum[i + 1] = preSum[i] + (nums.get(i) % modulo == k ? 1 : 0);
            }
            int[] cnt = new int[Math.min(n + 1, modulo)];
            long ans = 0;
            for (int s : preSum) {
                if (s >= k) {
                    ans += cnt[(s - k) % modulo];
                }
                cnt[s % modulo]++;
            }
            return ans;
        }
    }*/

   /* class Solution {
        public static Set<Integer> st = new HashSet<>();

        public static HashMap<Integer,Integer> cnt =new HashMap<>();
        public int countCompleteSubarrays(int[] nums) {
            for (int x : nums) {
                st.add(x);
            }
            int k = st.size();
            int ans = 0;
            int left = 0;
            for (int x : nums) {
                cnt.merge(x, 1, Integer::sum);
                while (cnt.size() == k) {
                    int out = nums[left];
                    if (cnt.merge(out, -1, Integer::sum) == 0) {
                        cnt.remove(out);
                    }
                    left++;
                }
                ans += left;
            }
            return ans;
        }
    }*/


    /*class Solution {
        public static final int MAX_N = 50;

        public static int[] map = new int[MAX_N];

        public void clear() {
            for (int i = 0; i < MAX_N; i++) {
                map[i] = 0;
            }
        }

        public int countSum(int x) {
            int sum = 0;
            while (x > 0) {
                sum += x % 10;
                x /= 10;
            }
            return sum;
        }

        public int countLargestGroup(int n) {
            clear();
            for (int i = 1; i <= n; i++) {
                map[countSum(i)]++;
            }
            int maxVal = 0;
            int cnt = 0;
            for (int i = 0; i < MAX_N; i++) {
                if (map[i] == maxVal) {
                    cnt++;
                } else if (map[i] > maxVal) {
                    maxVal = Math.max(maxVal, map[i]);
                    cnt = 1;
                }
            }
            return cnt;
        }
    }*/

    /*class Solution {
        private static final int MOD = 1_000_000_007;
        private static final int MAX_N = 10_000;
        private static final int MAX_E = 13;

        private static final List<Integer>[] list = new ArrayList[MAX_N + 1];
        private static final int[][] dp = new int[MAX_N + MAX_E][MAX_E + 1];

        private static boolean flag = false;

        private void init() {
            if (flag) {
                return;
            }
            flag = true;
            for (int x = 1; x < list.length; x++) {
                list[x] = new ArrayList<>();
                int tmp = x;
                for (int i = 2; i * i <= tmp; i++) {
                    int val = x;
                    for (; tmp % i == 0; tmp /= i) {
                        val++;
                    }
                    if (val > 0) {
                        list[x].add(val);
                    }
                }
                if (tmp > 1) {
                    list[x].add(1);
                }
            }
            for (int i = 0; i < MAX_N + MAX_E; i++) {
                dp[i][0] = 1;
                for (int j = 1; j <= Math.min(i, MAX_E); j++) {
                    dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
                }
            }
        }

        public int idealArrays(int n, int maxValue) {
            init();
            long ans = 0;
            for (int x = 1; x <= maxValue; x++) {
                long mul = 1;
                for (int val : list[x]) {
                    mul = mul * dp[n + val - 1][val] % MOD;
                }
                ans += mul;
            }
            return (int) (ans % MOD);
        }
    }*/

/*    class Solution {
        public int numberOfArrays(int[] differences, int lower, int upper) {
            long sum = 0;
            long minSum = 0;
            long maxSum = 0;
            for (int x : differences) {
                sum += x;
                minSum = Math.min(minSum, sum);
                maxSum = Math.max(maxSum, sum);
            }
            return (int) Math.max(upper - lower - maxSum + minSum + 1, 0);
        }
    }*/

/*    class Solution {
        public int numberOfArrays(int[] differences, int lower, int upper) {
            int  sum = 0;
            int minSum = 0;
            int maxSum = 0;
            for (int d : differences) {
                sum += d;
                minSum = Math.min(minSum, sum);
                maxSum = Math.max(maxSum, sum);
            }
            return Math.max(upper - lower - maxSum + minSum + 1, 0);
        }
    }*/


    /*class Solution {

        public static Map<Integer ,Integer> cnt = new HashMap<>();

        public int numRabbits(int[] answers) {
            cnt.clear();
            int ans = 0;
            for (int x : answers) {
                int val = cnt.getOrDefault(x, 0);
                if (val == 0) {
                    ans += x + 1;
                    cnt.put(x, x);
                } else {
                    cnt.put(x, val - 1);
                }
            }
            return ans;
        }
    }*/

    /*class Solution {
        public static Map<Integer,Integer> map = new HashMap<>();

        public long countBadPairs(int[] nums) {
            map.clear();
             int n = nums.length;
            long ans = (long) n * (n - 1) / 2;
            for (int i = 0; i < n; i++) {
                int v = nums[i] - i;
                int cnt = map.getOrDefault(v, 0);
                ans -= cnt;
                map.put(v, cnt + 1);
            }
            return ans;
        }
    }*/

/*    class Solution {
        public int countPairs(int[] nums, int k) {
            int cnt = 0;
            int n = nums.length;
            for (int i = 0; i < n; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (nums[i] == nums[j] && i * j % k == 0) {
                        cnt++;
                    }
                }
            }
            return cnt;
        }
    }*/

//    class Solution {
//
//        public static Map<Integer,Integer> map = new HashMap<>();
//        public long countGood(int[] nums, int k) {
//            map.clear();
//            long ans = 0;
//            int pairs = 0;
//            int left = 0;
//            for (int x : nums) {
//                pairs += map.merge(x, 1, Integer::sum) - 1;
//                while (pairs >= k) {
//                    pairs -= map.merge(nums[left], -1, Integer::sum);
//                    left++;
//                }
//                ans += left;
//            }
//            return ans;
//        }
//    }

/*    class Solution {

        public static Map<Integer,Integer> map = new HashMap<>();
        public long countGood(int[] nums, int k) {
            map.clear();
            long ans = 0;
            int pairs = 0;
            int left = 0;
            for (int x : nums) {
                int cnt = map.getOrDefault(x, 0);
                pairs += cnt;
                map.put(x, cnt + 1);
                while (pairs >= k) {
                    x = nums[left];
                    cnt = map.get(x);
                    pairs -= cnt - 1;
                    map.put(x, cnt - 1);
                    left++;
                }
                ans += left;
            }
            return ans;
        }
    }*/
//    class Solution {
//
//        public static final int MAX_N = 100010;
//
//        public static int[] tree = new int[MAX_N];
//
//        public void build(int n) {
//            Arrays.fill(tree, 0, n + 1, 0);
//        }
//
//        public static int lowBit(int x) {
//            return x & (-x);
//        }
//
//        public void add(int i, long val, int n) {
//            while (i <= n) {
//                tree[i] += val;
//                i += lowBit(i);
//            }
//        }
//
//        public static int getSum(int i) {
//            int ans = 0;
//            while (i > 0) {
//                ans += tree[i];
//                i -= lowBit(i);
//            }
//            return ans;
//        }
//
//        public long goodTriplets(int[] nums1, int[] nums2) {
//            int n = nums1.length;
//            int[] index = new int[n];
//            for (int i = 0; i < n; i++) {
//                index[nums1[i]] = i;
//            }
//            long ans = 0;
//            build(n);
//            for (int i = 0; i < n - 1; i++) {
//                int y = index[nums2[i]];
//                int less = getSum(y);
//                ans += (long) less * (n - 1 - y - (i - less));
//                add(y + 1, 1, n);
//            }
//            return ans;
//        }
//    }

/*    class Solution {
        public int countGoodTriplets(int[] arr, int a, int b, int c) {
            int ans = 0;
            for (int i = 0; i < arr.length - 2; i++) {
                for (int j = i + 1; j < arr.length - 1; j++) {
                    for (int k = j + 1; k < arr.length; k++) {
                        if (Math.abs(arr[i] - arr[j]) <= a && Math.abs(arr[j] - arr[k]) <= b
                                && Math.abs(arr[i] - arr[k]) <= c) {
                            ans++;
                        }
                    }
                }
            }
            return ans;
        }
    }*/

/*    class Solution {
        private static final int MOD = 1_000_000_007;

        public int countGoodNumbers(long n) {
            return (int) (pow(5, (n + 1) / 2) * pow(4, n / 2) % MOD);
        }

        private long pow(long a, long b) {
            long ans = 1;
            while (b > 0) {
                if ((b & 1) > 0) {
                    ans = ans * a % MOD;
                }
                a = a * a % MOD;
                b >>= 1;
            }
            return ans;
        }
    }*/

/*    class Solution {

        public static final int MAX_N = 100010;

        public static int[] factorial = new int[MAX_N + 1];

        public long countGoodIntegers(int n, int k) {
            Arrays.fill(factorial,0,n+1,0);
            factorial[0] = 1;
            for (int i = 1; i <= n; i++) {
                factorial[i] = factorial[i - 1] * i;
            }
            long ans = 0;
            Set<String> vis = new HashSet<>();
            int base = (int) Math.pow(10, (n - 1) / 2);
            for (int i = base; i < base * 10; i++) {
                String s = Integer.toString(i);
                s += new StringBuilder(s).reverse().substring(n % 2);
                if (Long.parseLong(s) % k > 0) {
                    continue;
                }
                char[] sortedS = s.toCharArray();
                Arrays.sort(sortedS);
                if (!vis.add(new String(sortedS))) {
                    continue;
                }
                int[] cnt = new int[10];
                for (char c : sortedS) {
                    cnt[c - '0']++;
                }
                int res = (n - cnt[0]) * factorial[n - 1];
                for (int c : cnt) {
                    res /= factorial[c];
                }
                ans += res;
            }
            return ans;
        }
    }*/

    /*class Solution {
        public int countSymmetricIntegers(int low, int high) {
            int ans = 0;
            for (int i = low; i <= high; i++) {
                char[] s = Integer.toString(i).toCharArray();
                int n = s.length;
                if (n % 2 > 0) {
                    continue;
                }
                int diff = 0;
                for (int j = 0; j < n / 2; j++) {
                    diff += s[j];
                }
                for (int j = n / 2; j < n; j++) {
                    diff -= s[j];
                }
                if (diff == 0) {
                    ans++;
                }
            }
            return ans;
        }
    }*/



/*    class Solution {

        public static final int MAX_N = 100010;

        public static long[] dp = new long[MAX_N];

        public long numberOfPowerfulInt(long start, long finish, int limit, String s) {
            String low = Long.toString(start);
            String high = Long.toString(finish);
            int n = high.length();
            low = "0".repeat(n - low.length()) + low;
            Arrays.fill(dp, 0, n + 1, -1);
            return dfs(0, true, true, low.toCharArray(), high.toCharArray(), limit, s.toCharArray());
        }

        private long dfs(int i, boolean limitLow, boolean limitHigh, char[] low, char[] high, int limit, char[] s) {
            if (i == high.length) {
                return 1;
            }
            if (!limitLow && !limitHigh && dp[i] != -1) {
                return dp[i];
            }
            int lo = limitLow ? low[i] - '0' : 0;
            int hi = limitHigh ? high[i] - '0' : 9;

            long res = 0;
            if (i < high.length - s.length) {
                for (int d = lo; d <= Math.min(hi, limit); d++) {
                    res += dfs(i + 1, limitLow && d == lo, limitHigh && d == hi, low, high, limit, s);
                }
            } else {
                int x = s[i - (high.length - s.length)] - '0';
                if (lo <= x && x <= Math.min(hi, limit)) {
                    res = dfs(i + 1, limitLow && x == lo, limitHigh && x == hi, low, high, limit, s);
                }
            }

            if (!limitLow && !limitHigh) {
                dp[i] = res;
            }
            return res;
        }
    }*/

/*    class Solution {
        public int[] smallestK(int[] arr, int k) {
            int n = arr.length;
            int[] ans = new int[k];
            if (k == 0) {
                return ans;
            }
            qSort(arr, 0, n - 1, k);
            for (int i = 0; i < k; i++) {
                ans[i] = arr[i];
            }
            return ans;
        }

        public void qSort(int[] arr, int l, int r, int k) {
            if (l >= r) {
                return;
            }
            int i = l;
            int j = r;
            int mid = new Random().nextInt(r - l + 1) + l;
            swap(arr, mid, l);
            int x = arr[l];
            while (i < j) {
                while (i < j && arr[j] >= x) {
                    j--;
                }
                while (i < j && arr[i] <= x) {
                    i++;
                }
                swap(arr, i, j);
            }
            swap(arr, i, l);
            if (i > k) {
                qSort(arr, l, i - 1, k);
            }
            if (i < k) {
                qSort(arr, i + 1, r, k);
            }
        }

        public void swap(int[] arr, int l, int r) {
            int tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
        }
    }*/


/*    class Solution {

        public static PriorityQueue<Integer> pq = new PriorityQueue<>();

        public int[] smallestK(int[] arr, int k) {
            pq.clear();
            for (int i = 0; i < arr.length; i++) {
                pq.add(arr[i]);
            }
            int[] ans = new int[k];
            for (int i = 0; i < k; i++) {
                ans[i] = pq.poll();
            }
            return ans;
        }
    }*/



/*    class Solution {
        public static final int MAX_N = 105;

        public static int[] cnt = new int[MAX_N];

        public static void clear() {
            for (int i = 0; i < MAX_N; i++) {
                cnt[i] = 0;
            }
        }

        public int minOperations(int[] nums, int k) {
            clear();
            int n = nums.length;
            int minValue = Integer.MAX_VALUE;
            for (int x : nums) {
                minValue = Math.min(minValue, x);
            }
            if (k > minValue) {
                return -1;
            }
            int count = 0;
            for (int i = 0; i < n; i++) {
                if (cnt[nums[i]] == 0) {
                    count++;
                }
                cnt[nums[i]]++;
            }
            if (k == minValue) {
                return count - 1;
            }
            return count;
        }
    }*/


/*    class Solution {
        private static final String[] map = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };

        public List<String> getValidT9Words(String digits, String[] words) {
            List<String> result = new ArrayList<>();
            if (digits == null || digits.length() == 0) {
                return result;
            }
            Set<String> wordSet = new HashSet<>(Arrays.stream(words).toList());
            dfs(result, wordSet, digits, "", 0);
            return result;
        }

        private void dfs(List<String> result, Set<String> wordSet, String digits, String current, int index) {
            if (index == digits.length()) {
                if (wordSet.contains(current)) {
                    result.add(current);
                }
                return;
            }
            String letters = map[digits.charAt(index) - '0'];
            for (char c : letters.toCharArray()) {
                dfs(result, wordSet, digits, current + c, index + 1);
            }
        }
    }*/


/*    class Solution {
        public static int MAX_N = 101;

        public static int[] cnt = new int[MAX_N];

        public int minimumOperations(int[] nums) {
            Arrays.fill(cnt, 0);
            int n = nums.length;
            for (int i = n-1; i >=0 ; i--) {
                if (cnt[nums[i]]++ > 0) {
                    return i / 3 + 1;
                }
            }
            return 0;
        }
    }*/


/*    class Solution {
        public int[] missingTwo(int[] nums) {
            int n = nums.length + 2;
            int totalSum = n * (1 + n) / 2;
            for (int x : nums) {
                totalSum -= x;
            }
            int sum = totalSum;
            int mid = totalSum / 2;
            int preSum = mid * (1 + mid) / 2;
            for (int x : nums) {
                if (x <= mid) {
                    preSum -= x;
                }
            }
            return new int[]{preSum, sum - preSum};
        }
    }*/


/*    class Solution {

        public static int MAX_N = 100010;

        public static int[] st = new int[MAX_N];

        public static int r;
        public int trap(int[] height) {
            int ans = 0;
            r = 0;
            for (int i = 0; i < height.length; i++) {
                while (r>0 && height[i] >= height[st[r-1]]) {
                    int h = height[st[--r]];
                    if (r == 0) {
                        break;
                    }
                    int left = st[r-1];
                    int val = Math.min(height[left], height[i]) - h;
                    ans += val * (i - left - 1);
                }
                st[r++] = i;
            }
            return ans;
        }
    }*/


/*    class Solution {

        public static List<Integer> list = new ArrayList<>();

        public int[] pondSizes(int[][] land) {
            int n = land.length;
            int m = land[0].length;
            list.clear();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (land[i][j] == 0) {
                        list.add(dfs(land, i, j));
                    }
                }
            }
            int[] ans = new int[list.size()];
            int i = 0;
            for (int x : list) {
                ans[i++] = x;
            }
            Arrays.sort(ans);
            return ans;
        }

        public int dfs(int[][] land, int x, int y) {
            if (x < 0 || x >= land.length || y < 0 || y >= land[x].length || land[x][y] != 0) {
                return 0;
            }
            land[x][y] = 1;
            int cnt = 1;
            for (int i = x - 1; i <= x + 1; i++) {
                for (int j = y - 1; j <= y + 1; j++) {
                    cnt += dfs(land, i, j);
                }
            }
            return cnt;
        }
    }*/



    /*class Solution {
        public boolean canPartition(int[] nums) {
            int sum = 0;
            for (int num : nums) {
                sum += num;
            }
            if (sum % 2 != 0) {
                return false;
            }
            int n = nums.length;
            int[][] dp = new int[n][sum / 2 + 1];
            for (int[] tmp : dp) {
                Arrays.fill(tmp, -1);
            }
            return dfs(n - 1, sum / 2, nums, dp);
        }

        public boolean dfs(int i, int j, int[] nums, int[][] dp) {
            if (i < 0) {
                return j == 0;
            }
            if (dp[i][j] != -1) {
                return dp[i][j] == 1;
            }
            boolean ans = j >= nums[i] && dfs(i - 1, j - nums[i], nums, dp) || dfs(i - 1, j, nums, dp);
            dp[i][j] = ans ? 1 : 0;
            return ans;
        }
    }*/

//    class Solution {
//        public int maxProduct(int[] nums, int k, int limit) {
//            final int MIN_SUM = -900;
//            final int MAX_SUM = 900;
//            final int OFFSET = 900;
//            int[][][] dp = new int[2][2][1801];
//
//            for (int p = 0; p < 2; p++) {
//                for (int h = 0; h < 2; h++) {
//                    Arrays.fill(dp[p][h], -1);
//                }
//            }
//            dp[0][0][OFFSET] = 1;
//
//            for (int num : nums) {
//                int[][][] newDp = new int[2][2][1801];
//                for (int p = 0; p < 2; p++) {
//                    for (int h = 0; h < 2; h++) {
//                        Arrays.fill(newDp[p][h], -1);
//                    }
//                }
//
//                for (int p = 0; p < 2; p++) {
//                    for (int h = 0; h < 2; h++) {
//                        for (int s = 0; s <= 1800; s++) {
//                            if (dp[p][h][s] == -1) continue;
//                            if (newDp[p][h][s] < dp[p][h][s]) {
//                                newDp[p][h][s] = dp[p][h][s];
//                            }
//                        }
//                    }
//                }
//
//                for (int p = 0; p < 2; p++) {
//                    for (int h = 0; h < 2; h++) {
//                        for (int s = 0; s <= 1800; s++) {
//                            int currentProd = dp[p][h][s];
//                            if (currentProd == -1) continue;
//
//                            int newP = (p + 1) % 2;
//                            int sum = s - OFFSET;
//                            int newSum = p == 0 ? sum + num : sum - num;
//
//                            if (newSum < MIN_SUM || newSum > MAX_SUM) continue;
//                            int newS = newSum + OFFSET;
//                            int newH = 1;
//
//                            int nextProd = (h == 0) ? num : currentProd * num;
//                            if (nextProd > limit) continue;
//
//                            if (newDp[newP][newH][newS] < nextProd) {
//                                newDp[newP][newH][newS] = nextProd;
//                            }
//                        }
//                    }
//                }
//
//                for (int p = 0; p < 2; p++) {
//                    for (int h = 0; h < 2; h++) {
//                        System.arraycopy(newDp[p][h], 0, dp[p][h], 0, 1801);
//                    }
//                }
//            }
//
//            int maxProduct = -1;
//            for (int p = 0; p < 2; p++) {
//                for (int s = 0; s <= 1800; s++) {
//                    int prod = dp[p][1][s];
//                    if (prod != -1 && (s - OFFSET) == k && prod <= limit) {
//                        maxProduct = Math.max(maxProduct, prod);
//                    }
//                }
//            }
//            return maxProduct != -1 ? maxProduct : -1;
//        }
//    }

    /*class Solution {

        public static final int MAX_N =100010;

        public static Node[] nodes = new Node[MAX_N];

        public static PriorityQueue<Pair> heap = new PriorityQueue<>((a, b) -> {
            if (a.sum != b.sum) {
                return Long.compare(a.sum, b.sum);
            } else {
                return Integer.compare(a.left.id, b.left.id);
            }
        });

        public int minimumPairRemoval(int[] nums) {
            int n = nums.length;
            if (n <= 1){
                return 0;
            }
            for (int i = 0; i < n; i++) {
                nodes[i] = new Node(nums[i], i);
            }
            for (int i = 0; i < n; i++) {
                if (i > 0) {
                    nodes[i].pre = nodes[i - 1];
                }
                if (i < n - 1) {
                    nodes[i].next = nodes[i + 1];
                }
            }
            int revCnt = 0;
            Node cur = nodes[0];
            while (cur != null && cur.next != null) {
                if (cur.val > cur.next.val) {
                    revCnt++;
                }
                cur = cur.next;
            }
            if (revCnt == 0) {
                return 0;
            }
            cur = nodes[0];
            heap.clear();
            while (cur != null && cur.next != null) {
                Node next = cur.next;
                heap.offer(new Pair(cur, next, cur.val + next.val));
                cur = cur.next;
            }
            int ans = 0;
            while (!heap.isEmpty()) {
                Pair pair = heap.poll();
                Node left = pair.left;
                Node right = pair.right;
                if (left.next != right || right.pre != left) {
                    continue;
                }
                long sum = left.val + right.val;
                Node node = new Node(sum, left.id);
                Node pre = left.pre;
                Node next = right.next;
                node.pre = pre;
                node.next = next;
                if (pre != null) {
                    pre.next = node;
                }
                if (next != null) {
                    next.pre = node;
                }
                int cnt1 = 0;
                if (pre != null) {
                    if (pre.val > left.val) {
                        cnt1++;
                    }
                }
                if (left.val > right.val) {
                    cnt1++;
                }
                if (next != null) {
                    if (right.val > next.val) {
                        cnt1++;
                    }
                }

                int cnt2 = 0;
                if (pre != null) {
                    if (pre.val > node.val){
                        cnt2++;
                    }
                }
                if (next != null) {
                    if (node.val > next.val) {
                        cnt2++;
                    }
                }
                revCnt += (cnt2 - cnt1);
                ans++;
                if (revCnt == 0) {
                    return ans;
                }
                if (pre != null) {
                    heap.offer(new Pair(pre, node, pre.val + node.val));
                }
                if (next != null) {
                    heap.offer(new Pair(node, next, node.val + next.val));
                }
            }
            return ans;
        }

        class Node {
            public long val;
            public Node pre;

            public Node next;
            public int id;

            public Node(long val, int id) {
                this.val = val;
                this.id = id;
            }
        }

        class Pair {
            public Node left;

            public Node right;

            public long sum;

            public Pair(Node left, Node right, long sum) {
                this.left = left;
                this.right = right;
                this.sum = sum;
            }
        }
    }*/


/*    class Packet {
        int source;
        int destination;
        int timestamp;

        public Packet(int source, int destination, int timestamp) {
            this.source = source;
            this.destination = destination;
            this.timestamp = timestamp;
        }
    }

    class Key {
        int source;
        int destination;
        int timestamp;

        public Key(int source, int destination, int timestamp) {
            this.source = source;
            this.destination = destination;
            this.timestamp = timestamp;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Key key = (Key) o;
            return source == key.source &&
                    destination == key.destination &&
                    timestamp == key.timestamp;
        }

        @Override
        public int hashCode() {
            return Objects.hash(source, destination, timestamp);
        }
    }

    class DestinationInfo {
        List<Integer> timestamps = new ArrayList<>();
        int start = 0;
    }

    public class Router {
       public   int memoryLimit;
        public  Queue<Packet> queue = new LinkedList<>();
        public Set<Key> keySet = new HashSet<>();
        public  Map<Integer, DestinationInfo> destinationMap = new HashMap<>();

        public Router(int memoryLimit) {
            this.memoryLimit = memoryLimit;
        }

        public boolean addPacket(int source, int destination, int timestamp) {
            Key key = new Key(source, destination, timestamp);
            if (keySet.contains(key)) {
                return false;
            }

            if (queue.size() == memoryLimit) {
                Packet oldest = queue.poll();
                Key oldestKey = new Key(oldest.source, oldest.destination, oldest.timestamp);
                keySet.remove(oldestKey);
                DestinationInfo di = destinationMap.get(oldest.destination);
                if (di != null) {
                    di.start++;
                }
            }

            Packet newPacket = new Packet(source, destination, timestamp);
            queue.offer(newPacket);
            keySet.add(key);

            DestinationInfo di = destinationMap.computeIfAbsent(destination, k -> new DestinationInfo());
            di.timestamps.add(timestamp);

            return true;
        }

        public int[] forwardPacket() {
            if (queue.isEmpty()) {
                return new int[0];
            }

            Packet packet = queue.poll();
            Key key = new Key(packet.source, packet.destination, packet.timestamp);
            keySet.remove(key);

            DestinationInfo di = destinationMap.get(packet.destination);
            if (di != null) {
                di.start++;
            }

            return new int[]{packet.source, packet.destination, packet.timestamp};
        }

        public int getCount(int destination, int startTime, int endTime) {
            DestinationInfo di = destinationMap.get(destination);
            if (di == null) {
                return 0;
            }

            int size = di.timestamps.size();
            int startIdx = di.start;

            if (startIdx >= size) {
                return 0;
            }

            int left = lowerBound(di.timestamps, startIdx, size - 1, startTime);
            int rightUpper = upperBound(di.timestamps, startIdx, size - 1, endTime);
            int right = rightUpper - 1;

            if (left > right) {
                return 0;
            }

            return right - left + 1;
        }

        private int lowerBound(List<Integer> list, int from, int to, int target) {
            int low = from;
            int high = to + 1;

            while (low < high) {
                int mid = (low + high) / 2;
                if (list.get(mid) < target) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }

            return low;
        }

        private int upperBound(List<Integer> list, int from, int to, int target) {
            int low = from;
            int high = to + 1;
            while (low < high) {
                int mid = (low + high) / 2;
                if (list.get(mid) <= target) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }

            return low;
        }
    }*/



/*    public class Solution {
        public int minimumPairRemoval(int[] nums) {
            int op = 0;
            List<Integer> list = new ArrayList<>();
            for (int num : nums) {
                list.add(num);
            }
            while (true) {
                if (check(list)) {
                    break;
                }
                int minSum = Integer.MAX_VALUE;
                int idx = -1;
                for (int i = 0; i < list.size() - 1; i++) {
                    int sum = list.get(i) + list.get(i + 1);
                    if (sum < minSum) {
                        minSum = sum;
                        idx = i;
                    }
                }
                int val = list.get(idx) + list.get(idx + 1);
                list.remove(idx + 1);
                list.set(idx, val);
                op++;
            }
            return op;
        }

        private boolean check(List<Integer> list) {
            for (int i = 0; i < list.size() - 1; i++) {
                if (list.get(i) > list.get(i + 1)) {
                    return false;
                }
            }
            return true;
        }
    }*/


//    class Solution {
//        public ListNode partition(ListNode head, int x) {
//            ListNode smallHead = new ListNode(0);
//            ListNode bigHead = new ListNode(0);
//            ListNode small = smallHead;
//            ListNode big = bigHead;
//            while(head != null){
//                if(head.val < x){
//                    small.next = head;
//                    small = small.next;
//                }else{
//                    big.next = head;
//                    big = big.next;
//                }
//                head = head.next;
//            }
//            small.next = bigHead.next;
//            return smallHead.next;
//        }
//    }

//    class Solution {
//
//        public static final int MAX_N = 10010;
//
//        public static int[] dp = new int[MAX_N];
//
//        public static int[] status = new int[MAX_N];
//
//        public static void clear(int n) {
//            Arrays.fill(dp, 0,n+1, 0);
//            Arrays.fill(status, 0,n+1,0);
//        }
//
//        public List<Integer> largestDivisibleSubset(int[] nums) {
//            int n = nums.length;
//            clear(n);
//            Arrays.sort(nums);
//            for (int i = 0,len,pre; i < n; i++) {
//                len = 1;
//                pre = i;
//                for (int j = 0; j < i; j++) {
//                    if (nums[i] % nums[j] == 0) {
//                        if (dp[j] + 1 > len) {
//                            len = dp[j] + 1;
//                            pre = j;
//                        }
//                    }
//                }
//                dp[i] = len;
//                status[i] = pre;
//            }
//            int maxLen = -1;
//            int idx = -1;
//            for (int i = 0; i < n; i++) {
//                if (dp[i] > maxLen) {
//                    idx = i;
//                    maxLen = dp[i];
//                }
//            }
//
//            List<Integer> ans = new ArrayList<>();
//            while (ans.size() != maxLen) {
//                ans.add(nums[idx]);
//                idx = status[idx];
//            }
//            return ans;
//        }
//    }


//    class Solution {
//        public int subsetXORSum(int[] nums) {
//            int n = nums.length;
//            int ans = 0;
//            for (int mask = 1; mask < (1 << n); mask++) {
//                int val = 0;
//                for (int i = 0; i < n; i++) {
//                    if (((mask >> i) & 1) == 1) {
//                        val ^= nums[i];
//                    }
//                }
//                ans += val;
//            }
//            return ans;
//        }
//    }


//    class Solution {
//        public static TreeNode ans;
//
//        public static int maxDepth;
//
//        public TreeNode lcaDeepestLeaves(TreeNode root) {
//            maxDepth = 0;
//            dfs(root, 0);
//            return ans;
//        }
//
//        public static int dfs(TreeNode root, int depth) {
//            if (root == null) {
//                maxDepth = Math.max(maxDepth, depth);
//                return depth;
//            }
//            int lmax = dfs(root.left, depth + 1);
//            int rmax = dfs(root.right, depth + 1);
//            if (lmax == rmax && lmax == maxDepth) {
//                ans = root;
//            }
//            return Math.max(lmax, rmax);
//        }
//    }


//    class Solution {
//        public long maximumTripletValue(int[] nums) {
//            int n = nums.length;
//            int[] suf = new int[n + 1];
//            for (int i = n - 1; i > 1; i--) {
//                suf[i] = Math.max(suf[i + 1], nums[i]);
//            }
//
//            long ans = 0;
//            int pre = nums[0];
//            for (int j = 1; j < n - 1; j++) {
//                ans = Math.max(ans, (long) (pre - nums[j]) * suf[j + 1]);
//                pre = Math.max(pre, nums[j]);
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public long maximumTripletValue(int[] nums) {
//            int n = nums.length;
//            int[] suf = new int[n + 1];
//            for (int i = n - 1; i > 1; i--) {
//                suf[i] = Math.max(suf[i + 1], nums[i]);
//            }
//            long ans = 0;
//            int preSum = nums[0];
//            for (int j = 1; j < n - 1; j++) {
//                ans = Math.max(ans, (long) (preSum - nums[j]) * suf[j + 1]);
//                preSum = Math.max(preSum, nums[j]);
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public long mostPoints(int[][] questions) {
//            long[] dp = new long[questions.length];
//            return dfs(0, questions, dp);
//        }
//
//        private long dfs(int i, int[][] questions, long[] dp) {
//            if (i >= dp.length) {
//                return 0;
//            }
//            if (dp[i] > 0) {
//                return dp[i];
//            }
//            long no = dfs(i + 1, questions, dp);
//            long yes = dfs(i + questions[i][1] + 1, questions, dp) + questions[i][0];
//            dp[i] = Math.max(no, yes);
//            return dp[i];
//        }
//    }


//    class Solution {
//        public long mostPoints(int[][] questions) {
//            return dfs(0, questions);
//        }
//
//        private long dfs(int i, int[][] questions) {
//            if (i >= questions.length) {
//                return 0;
//            }
//            long no = dfs(i + 1, questions);
//            long yes = dfs(i + questions[i][1] + 1, questions) + questions[i][0];
//            long ans = Math.max(no, yes);
//            return ans;
//        }
//    }


//    public class Solution {
//        public int longestPalindrome(String s, String t) {
//            int maxLen = 0;
//            int m = s.length();
//            int n = t.length();
//            maxLen = Math.max(maxLen, expandCenter(s));
//            maxLen = Math.max(maxLen, expandCenter(t));
//            for (int i = 0; i <= m + n; i++) {
//                int len1 = expandAcross(s, t, i, i);
//                int len2 = expandAcross(s, t, i, i + 1);
//                maxLen = Math.max(maxLen, Math.max(len1, len2));
//            }
//            return maxLen;
//        }
//
//        private int expandCenter(String str) {
//            int max = 0;
//            for (int i = 0; i < str.length(); i++) {
//                int len1 = expand(str, i, i);
//                int len2 = expand(str, i, i + 1);
//                max = Math.max(max, Math.max(len1, len2));
//            }
//            return max;
//        }
//
//        private int expand(String s, int left, int right) {
//            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
//                left--;
//                right++;
//            }
//            return right - left - 1;
//        }
//
//        private int expandAcross(String s, String t, int leftCenter, int rightCenter) {
//            int L = leftCenter;
//            int R = rightCenter;
//            while (L >= 0 && R < s.length() + t.length() && getChar(L, s, t) == getChar(R, s, t)) {
//                L--;
//                R++;
//            }
//            return R - L - 1;
//        }
//
//        private char getChar(int pos, String s, String t) {
//            if (pos < s.length()) {
//                return s.charAt(pos);
//            } else {
//                return t.charAt(pos - s.length());
//            }
//        }
//    }


//    public class Solution {
//        public int longestPalindrome(String s, String t) {
//            int maxLen = 0;
//            int m = s.length();
//            int n = t.length();
//
//            for (int i = 0; i <= m; i++) {
//                for (int j = 0; j <= n; j++) {
//                    for (int k = i; k <= m; k++) {
//                        for (int l = j; l <= n; l++) {
//                            String sSub = s.substring(i, k);
//                            String tSub = t.substring(j, l);
//                            String combined = sSub + tSub;
//                            if (isPalindrome(combined)) {
//                                maxLen = Math.max(maxLen, combined.length());
//                            }
//                        }
//                    }
//                }
//            }
//            return maxLen;
//        }
//
//        private boolean isPalindrome(String str) {
//            int left = 0;
//            int right = str.length() - 1;
//            while (left < right) {
//                if (str.charAt(left) != str.charAt(right)) {
//                    return false;
//                }
//                left++;
//                right--;
//            }
//            return true;
//        }
//    }


//    class Solution {
//        public String addSpaces(String s, int[] spaces) {
//            int pre = 0;
//            StringBuilder sb = new StringBuilder();
//            for (int i = 0; i < spaces.length; i++) {
//                sb.append(s.substring(pre, spaces[i]));
//                sb.append(" ");
//                pre = spaces[i];
//            }
//            return sb.toString();
//        }
//    }

//    class Solution {
//        public static final int MOD = 1_000_000_007;
//
//        public static int[][] dirs = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
//
//        public static int[][][] dp;
//
//        public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
//            dp = new int[m][n][maxMove + 1];
//            for (int i = 0; i < m; i++) {
//                for (int j = 0; j < n; j++) {
//                    for (int k = 0; k <= maxMove; k++) {
//                        dp[i][j][k] = -1;
//                    }
//                }
//            }
//            return dfs(startRow, startColumn, maxMove, m, n);
//        }
//
//        int dfs(int x, int y, int k, int m, int n) {
//            if (x < 0 || x >= m || y < 0 || y >= n) return 1;
//            if (k == 0) return 0;
//            if (dp[x][y][k] != -1) return dp[x][y][k];
//            int ans = 0;
//            for (int[] d : dirs) {
//                int nx = x + d[0], ny = y + d[1];
//                ans += dfs(nx, ny, k - 1, m, n);
//                ans %= MOD;
//            }
//            dp[x][y][k] = ans;
//            return ans;
//        }
//    }

//    class Solution {
//
//        public static final int MAX_N = 100_010;
//
//        public static int[] que = new int[MAX_N];
//
//        public static int l, r;
//
//        public int longestCycle(int[] edges) {
//            int ans = -1;
//            int n = edges.length;
//            int[] in = new int[n];
//            for (int i = 0; i < n; i++) {
//                if (edges[i] >= 0) {
//                    in[edges[i]]++;
//                }
//            }
//            boolean[] visit = new boolean[n];
//            l = r = 0;
//            for (int i = 0; i < n; i++) {
//                if (in[i] == 0) {
//                    que[r++] = i;
//                }
//            }
//            while (l < r) {
//                int node = que[l++];
//                visit[node] = true;
//                int next = edges[node];
//                if (next >= 0) {
//                    in[next]--;
//                    if (in[next] == 0) {
//                        que[r++] = next;
//                    }
//                }
//            }
//            for (int i = 0; i < n; i++) {
//                if (visit[i]) {
//                    continue;
//                }
//                int len = 0;
//                int cur = i;
//                while (!visit[cur]) {
//                    visit[cur] = true;
//                    cur = edges[cur];
//                    len++;
//                }
//                ans = Math.max(ans, len);
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int minimizedStringLength(String s) {
//            int[] cnt = new int[26];
//            int ans = 0;
//            char[] str = s.toCharArray();
//            for (char c : str) {
//                if (cnt[c-'a'] == 0) {
//                    cnt[c-'a']++;
//                    ans++;
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public static final int MAX_N = 100_010;
//
//        public long minimumCost(String s) {
//            long ans = 0L;
//            int n  = s.length();
//            for (int i = 1; i < n; i++) {
//                if (s.charAt(i - 1) != s.charAt(i)) {
//                    ans += Math.min(i, n - i);
//                }
//            }
//            return ans;
//        }
//    }


//    class Solution {
//        public int minimumSum(int n, int k) {
//            int cnt = Math.min(k / 2, n);
//            return (cnt * (cnt + 1)) / 2 + (2 * k + n - cnt - 1) * (n - cnt) / 2;
//        }
//    }

//    class Solution {
//        public static Set<Integer> st = new HashSet<>();
//
//        public int[][] differenceOfDistinctValues(int[][] grid) {
//            int n = grid.length;
//            int m = grid[0].length;
//            int[][] ans = new int[n][m];
//            for (int i = 0; i < n; i++) {
//                for (int j = 0; j < m; j++) {
//                    st.clear();
//                    for (int x = i - 1, y = j - 1; x >= 0 && y >= 0; x--, y--) {
//                        st.add(grid[x][y]);
//                    }
//                    int topLeft = st.size();
//                    st.clear();
//                    for (int x = i + 1, y = j + 1; x < n && y < m; x++, y++) {
//                        st.add(grid[x][y]);
//                    }
//                    int bottomRight = st.size();
//                    ans[i][j] = Math.abs(topLeft - bottomRight);
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int countPrefixes(String[] words, String s) {
//            int ans = 0;
//            int n = words.length;
//            for (int i = 0; i < n; i++) {
//                if (s.startsWith(words[i])) {
//                    ans++;
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public boolean canBeValid(String s, String locked) {
//            int n = s.length();
//            if (n % 2 > 0) {
//                return false;
//            }
//            char[] str = s.toCharArray();
//            int cnt = 0;
//            int maxV = 0;
//            for (int i = 0, x = 0; i < n; i++) {
//                if (locked.charAt(i) == '1') {
//                    x = str[i] == '(' ? 1 : -1;
//                    maxV += x;
//                    if (maxV < 0) {
//                        return false;
//                    }
//                    cnt += x;
//                } else {
//                    maxV++;
//                    cnt--;
//                }
//                if (cnt < 0) {
//                    cnt = 1;
//                }
//            }
//            return cnt == 0;
//        }
//    }

//    class Solution {
//        public int[] rowAndMaximumOnes(int[][] mat) {
//            int idx = -1;
//            int ans = -1;
//            int n = mat.length;
//            int m = mat[0].length;
//            for (int i = 0; i < n; i++) {
//                int x = 0;
//                for (int j = 0; j < m; j++) {
//                    x += mat[i][j];
//                }
//                if (x > ans) {
//                    idx = i;
//                    ans = x;
//                }
//            }
//            return new int[] { idx, ans };
//        }
//    }


//    class Solution {
//        public long maximumOr(int[] nums, int k) {
//            int n = nums.length;
//            int[] last = new int[n];
//            for (int i = n - 2; i >= 0; i--) {
//                last[i] = last[i + 1] | nums[i + 1];
//            }
//            long ans = 0;
//            int pre = 0;
//            for (int i = 0; i < n; i++) {
//                ans = Math.max(ans, pre | ((long) (nums[i]) << k) | last[i]);
//                pre |= nums[i];
//            }
//            return ans;
//        }
//    }


//    class Solution {
//        public static final int MAX_N = 100005;
//
//        public static int[] que = new int[MAX_N];
//
//        public static int l, r;
//
//        public int[] minReverseOperations(int n, int p, int[] banned, int k) {
//            Set<Integer> ban = new HashSet<>();
//            for (int b : banned) {
//                ban.add(b);
//            }
//
//            TreeSet<Integer>[] indices = new TreeSet[]{new TreeSet<>(), new TreeSet<>()};
//            for (int i = 0; i < n; i++) {
//                if (i != p && !ban.contains(i)) {
//                    indices[i % 2].add(i);
//                }
//            }
//
//            int[] ans = new int[n];
//            Arrays.fill(ans, -1);
//            ans[p] = 0;
//            l = r = 0;
//            que[r++] = p;
//            while (l < r) {
//                int i = que[l++];
//                int mn = Math.max(i - k + 1, k - i - 1);
//                int mx = Math.min(i + k - 1, n * 2 - k - i - 1);
//                TreeSet<Integer> set = indices[mn % 2];
//                for (Iterator<Integer> it = set.tailSet(mn).iterator(); it.hasNext(); it.remove()) {
//                    int j = it.next();
//                    if (j > mx) {
//                        break;
//                    }
//                    ans[j] = ans[i] + 1;
//                    que[r++] = j;
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public static Map<Integer, Integer> cnt = new HashMap<>();
//
//        public List<List<Integer>> findMatrix(int[] nums) {
//            cnt.clear();
//            for (int x : nums) {
//                cnt.merge(x, 1, Integer::sum);
//            }
//            List<List<Integer>> ans = new ArrayList<>();
//            while (!cnt.isEmpty()) {
//                List<Integer> cur = new ArrayList<>(cnt.keySet());
//                ans.add(cur);
//                for (Integer x : cur) {
//                    cnt.merge(x, -1, Integer::sum);
//                    if (cnt.get(x) == 0) {
//                        cnt.remove(x);
//                    }
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int minSwaps(String s) {
//            int cnt = 0;
//            char[] str = s.toCharArray();
//            for (int i = 0; i < str.length; i++) {
//                if (str[i] == '[' || cnt == 0) {
//                    cnt++;
//                } else {
//                    cnt--;
//                }
//            }
//            return cnt / 2;
//        }
//    }

//    class Solution {
//        public int largestVariance(String s) {
//            int n = s.length();
//            char[] str = s.toCharArray();
//            int ans = 0;
//            for (int i = 1; i < n && str[i] == str[0]; i++) {
//                if (i == n - 1) {
//                    return 0;
//                }
//            }
//            for (int i = 0; i < 26; i++) {
//                for (int j = 0; j < 26; j++) {
//                    if (i != j) {
//                        int st = 0;
//                        int stHas = -99999;
//                        for (int k = 0; k < n; k++) {
//                            if (str[k] - 97 == i) {
//                                st++;
//                                stHas++;
//                            }
//                            if (str[k] - 97 == j) {
//                                st--;
//                                stHas = st;
//                            }
//                            if (st < 0) {
//                                st = 0;
//                            }
//                            if (stHas > ans) {
//                                ans = stHas;
//                            }
//                        }
//                    }
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int scoreOfString(String s) {
//            int ans = 0;
//            for(int i =1;i<s.length();i++){
//                ans+=Math.abs(s.charAt(i)-s.charAt(i-1));
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public boolean isBalanced(String num) {
//            int evenSum = 0;
//            int oddSum = 0;
//            for (int i = 0; i < num.length(); i++) {
//                int digit = Character.getNumericValue(num.charAt(i));
//                if (i % 2 == 0) {
//                    evenSum += digit;
//                } else {
//                    oddSum += digit;
//                }
//            }
//            return evenSum == oddSum;
//        }
//    }

//
//    public static void HundredKun() {
//        List<int[]> ans = new ArrayList<>();
//        for (int x = 0; x <= 20; x++) {
//            for (int y = 0; y <= 33; y++) {
//                int z = 100 - x - y;
//                if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
//                    ans.add(new int[]{x, y, z});
//                }
//            }
//        }
//        for (int[] arr : ans) {
//            System.out.println("公鸡" + arr[0] + "只，母鸡" + arr[1] + "只，小鸡" + arr[2] + "只");
//        }
//    }
//
//    public static void testFishOrDry() {
//        // 测试数据
//        int[] testCases = {
//                -1,   // 无效输入
//                0,    // 无效输入
//                1,    // 第1天，打鱼
//                3,    // 第3天，打鱼
//                4,    // 第4天，晒网
//                5,    // 第5天，晒网
//                6,    // 第6天，打鱼
//                10,   // 第10天，晒网
//                11,   // 第11天，打鱼
//                15,   // 第15天，晒网
//                16,   // 第16天，打鱼
//                103   // 第103天，打鱼
//        };
//
//        // 预期输出
//        String[] expectedOutputs = {
//                "家里请高人吧",
//                "家里请高人吧",
//                "打鱼",
//                "打鱼",
//                "晒网",
//                "晒网",
//                "打鱼",
//                "晒网",
//                "打鱼",
//                "晒网",
//                "打鱼",
//                "打鱼"
//        };
//
//        // 运行测试
//        for (int i = 0; i < testCases.length; i++) {
//            System.out.print("输入: " + testCases[i] + " 预期输出: " + expectedOutputs[i] + " 实际输出: ");
//            FishOrDry(testCases[i]);
//        }
//    }
//
//    public static void FishOrDry(int n) {
//        if (n <= 0) {
//            System.out.println("家里请高人吧");
//            return;
//        }
//        boolean flag = n % 5 == 4 || n % 5 == 0 ? false : true;
//        if (flag) {
//            System.out.println("打鱼");
//        } else {
//            System.out.println("晒网");
//        }
//    }

//    class Solution {
//        public List<List<Integer>> ans = new ArrayList<>();
//
//        public List<Integer> path = new ArrayList<>();
//
//        public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
//            path.add(0);
//            dfs(graph, 0, graph.length - 1);
//            return ans;
//        }
//
//        public void dfs(int[][] graph, int i, int n) {
//            if (i == n) {
//                ans.add(new ArrayList<>(path));
//                return;
//            }
//            for (int next : graph[i]) {
//                path.add(next);
//                dfs(graph, next, n);
//                path.remove(path.size() - 1);
//            }
//        }
//    }

//    class Solution {
//        public long countOfSubstrings(String word, int k) {
//            char[] str = word.toCharArray();
//            return solve(str, k) - solve(str, k + 1);
//        }
//
//        public long solve(char[] str, int k) {
//            long ans = 0;
//            HashMap<Character, Integer> yuanMap = new HashMap<>();
//            int left = 0;
//            int n = str.length;
//            int cnt = 0;
//            for (int right = 0; right < n; right++) {
//                if (isFlag(str[right])) {
//                    yuanMap.merge(str[right], 1, Integer::sum);
//                } else {
//                    cnt++;
//                }
//                while (yuanMap.size() == 5 && cnt >= k) {
//                    char cur = str[left++];
//                    if (isFlag(cur)) {
//                        yuanMap.merge(cur, -1, Integer::sum);
//                        if (yuanMap.get(cur) == 0) {
//                            yuanMap.remove(cur);
//                        }
//                    } else {
//                        cnt--;
//                    }
//                }
//                ans += left;
//            }
//            return ans;
//        }
//
//        public boolean isFlag(char c) {
//            if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
//                return true;
//            }
//            return false;
//        }
//    }

//    class Solution {
//
//        public int countOfSubstrings(String word, int k) {
//            char[] str = word.toCharArray();
//            return solve(str, k) - solve(str, k + 1);
//        }
//
//        public int solve(char[] str, int k) {
//            int ans = 0;
//            int cnt = 0;
//            int n = str.length;
//            HashMap<Character, Integer> map = new HashMap<>();
//            for (int left = 0, right = 0; right < n; right++) {
//                if (isFlag(str[right])) {
//                    map.merge(str[right], 1, Integer::sum);
//                } else {
//                    cnt++;
//                }
//                while (map.size() == 5 && cnt >= k) {
//                    if (isFlag(str[left])) {
//                        map.merge(str[left], -1, Integer::sum);
//                        if (map.get(str[left]) == 0) {
//                            map.remove(str[left]);
//                        }
//                    } else {
//                        cnt--;
//                    }
//                    left++;
//                }
//                ans += left;
//            }
//            return ans;
//        }
//
//        private boolean isFlag(char c) {
//            if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
//                return true;
//            }
//            return false;
//        }
//    }

//    class Solution {
//        public int sumOfBeauties(int[] nums) {
//            int n = nums.length;
//            int[] lastMin = new int[n];
//            lastMin[n - 1] = nums[n - 1];
//            for (int i = n - 2; i >= 1; i--) {
//                lastMin[i] = Math.min(lastMin[i + 1], nums[i]);
//            }
//            int preMax = nums[0];
//            int ans = 0;
//            for (int i = 1, x = 0; i < n - 1; i++) {
//                x = nums[i];
//                if (preMax < x && x < lastMin[i + 1]) {
//                    ans += 2;
//                } else if (x > nums[i - 1] && x < nums[i + 1]) {
//                    ans++;
//                }
//                preMax = Math.max(preMax, x);
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int divisorSubstrings(int num, int k) {
//            long m = (long) Math.pow(10, k);
//            int cnt = 0;
//            for (int n = num; n >= m / 10; n /= 10) {
//                int x = (int) (n % m);
//                if (x > 0 && num % x == 0) {
//                    cnt++;
//                }
//            }
//            return cnt;
//        }
//    }

//    class Solution {
//        public int[] maximumBeauty(int[][] items, int[] queries) {
//            Arrays.sort(items, (x, y) -> x[0] - y[0]);
//            Integer[] idx = new Integer[queries.length];
//            Arrays.setAll(idx, i -> i);
//            Arrays.sort(idx, (x, y) -> queries[x] - queries[y]);
//            int[] result = new int[queries.length];
//            int ans = 0;
//            int j = 0;
//            for (int i : idx) {
//                int q = queries[i];
//                while (j < items.length && items[j][0] <= q) {
//                    ans = Math.max(ans, items[j][1]);
//                    j++;
//                }
//                result[i] = ans;
//            }
//            return result;
//        }
//    }

//    class Solution {
//        public long maximumBeauty(int[] flowers, long newFlowers, int target, int full, int partial) {
//            int n = flowers.length;
//            long lf = newFlowers -  target * n;
//            for (int i = 0; i < n; i++) {
//                flowers[i] = Math.min(flowers[i], target);
//                lf += flowers[i];
//            }
//            Arrays.sort(flowers);
//            if (lf == newFlowers) {
//                return (long) n * full;
//            }
//            if (lf >= 0) {
//                return Math.max((long) (target - 1) * partial + (long) (n - 1) * full, (long) n * full);
//            }
//            long ans = 0;
//            long preSum = 0;
//            int j = 0;
//            for (int i = 1; i <= n; i++) {
//                lf += target - flowers[i - 1];
//                if (lf < 0) {
//                    continue;
//                }
//
//                while (j < i && (long) flowers[j] * j <= preSum + lf) {
//                    preSum += flowers[j];
//                    j++;
//                }
//                long avg = (lf + preSum) / j;
//                long curVal = avg * partial +  (n - i) * full;
//                ans = Math.max(ans, curVal);
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int ans = -1;
//
//        public int beautifulSubsets(int[] nums, int k) {
//            Map<Integer, Integer> cnt = new HashMap<>();
//            dfs(0, nums, k, cnt);
//            return ans;
//        }
//
//        private void dfs(int i, int[] nums, int k, Map<Integer, Integer> cnt) {
//            if (i == nums.length) {
//                ans++;
//                return;
//            }
//            dfs(i + 1, nums, k, cnt);
//            int cur = nums[i];
//            if (cnt.getOrDefault(cur - k, 0) == 0 && cnt.getOrDefault(cur + k, 0) == 0) {
//                cnt.merge(cur, 1, Integer::sum);
//                dfs(i + 1, nums, k, cnt);
//                cnt.merge(cur, -1, Integer::sum);
//            }
//        }
//    }

//    class Solution {
//        public long beautifulSubarrays(int[] nums) {
//            long ans = 0;
//            int s = 0;
//            Map<Integer, Integer> cnt = new HashMap<>(nums.length + 1); // 预分配空间
//            cnt.put(0, 1);
//            for (int x : nums) {
//                s ^= x;
//                int c = cnt.getOrDefault(s, 0);
//                ans += c;
//                cnt.put(s, c + 1);
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public String breakPalindrome(String palindrome) {
//            char[] s = palindrome.toCharArray();
//            int n = s.length;
//            if (n == 1) {
//                return "";
//            }
//            for (int i = 0; i < n / 2; i++) {
//                if (s[i] != 'a') {
//                    s[i] = 'a';
//                    return new String(s);
//                }
//            }
//            s[n - 1] = 'b';
//            return new String(s);
//        }
//    }

//    class Solution {
//        public boolean checkPartitioning(String s) {
//            return PartitioningK(s, 3) == 0;
//        }
//
//        public int PartitioningK(String str, int k) {
//            char[] s = str.toCharArray();
//            int n = s.length;
//            int[][] dp = new int[k][n];
//            for (int i = 0; i < k; i++) {
//                Arrays.fill(dp[i], -1);
//            }
//            int[][] changeDp = new int[n][n];
//            for (int i = 0; i < n; i++) {
//                Arrays.fill(changeDp[i], -1);
//            }
//            dfs(s, k - 1, n - 1, dp,changeDp);
//            return dp[k - 1][n - 1];
//        }
//
//        public static int dfs(char[] s, int cnt, int r, int[][] dp,int[][] changeDp) {
//            if (cnt == 0) {
//                return getCnt(s, 0, r,changeDp);
//            }
//            if (dp[cnt][r] != -1) {
//                return dp[cnt][r];
//            }
//            int res = Integer.MAX_VALUE;
//            for (int l = cnt; l <= r; l++) {
//                res = Math.min(res, dfs(s, cnt - 1, l - 1, dp,changeDp) + getCnt(s, l, r,changeDp));
//            }
//            return dp[cnt][r] = res;
//        }
//
//        public static int getCnt(char[] s, int left, int right,int[][] changeDp) {
//            if(left>=right) return 0;
//            if(changeDp[left][right] != -1){
//                return changeDp[left][right];
//            }
//            int ans = getCnt(s,left+1,right-1,changeDp);
//            if(s[left] != s[right]){
//                ans++;
//            }
//            return changeDp[left][right] = ans;
//        }
//    }

//    class Solution {
//        public int findLength(int[] A, int[] B) {
//            return A.length <= B.length ? findMax(A, B) : findMax(B, A);
//        }
//
//        private int findMax(int[] A, int[] B) {
//            int n = A.length;
//            int m = B.length;
//            int max = 0;
//
//        /*
//        A:           |*|*|*|*|
//        B: |*|*|*|*|*|*|
//                 ↓
//        A:       |*|*|*|*|
//        B: |*|*|*|*|*|*|
//         */
//            for (int len = 1; len < n; len++) {
//                max = Math.max(max, find(A, B, 0, m - len, len));
//            }
//
//        /*
//        A:     |*|*|*|*|
//        B: |*|*|*|*|*|*|
//                 ↓
//        A: |*|*|*|*|
//        B: |*|*|*|*|*|*|
//         */
//            for (int j = m - n; j >= 0; j--) {
//                max = Math.max(max, find(A, B, 0, j, n));
//            }
//
//        /*
//        A: |*|*|*|*|
//        B:   |*|*|*|*|*|*|
//                 ↓
//        A: |*|*|*|*|
//        B:       |*|*|*|*|*|*|
//         */
//            for (int len = n - 1; len > 0; len--) {
//                max = Math.max(max, find(A, B, n - len, 0, len));
//            }
//
//            return max;
//        }
//
//        private int find(int[] A, int[] B, int i, int j, int len) {
//            int max = 0, count = 0;
//            for (int k = 0; k < len; k++) {
//                if (A[i + k] == B[j + k]) {
//                    count++;
//                } else {
//                    max = Math.max(max, count);
//                    count = 0;
//                }
//            }
//            max = Math.max(max, count);
//            return max;
//        }
//    }

//    class Solution {
//        public static int getChageCnt(char[] s, int left, int right) {
//            int ans = 0;
//            while (left <= right) {
//                if (s[left++] != s[right--]) {
//                    ans++;
//                }
//            }
//            return ans;
//        }
//
//        public int palindromePartition(String str, int k) {
//            char[] s = str.toCharArray();
//            int n = str.length();
//            int[][] dp = new int[k][n];
//            for (int i = 0; i < k; i++) {
//                Arrays.fill(dp[i], -1);
//            }
//            return dfs(s, n - 1, k - 1, dp);
//        }
//
//        public static int dfs(char[] s, int r, int cnt, int[][] dp) {
//            if (cnt == 0) {
//                return getChageCnt(s, 0, r);
//            }
//            if (dp[cnt][r] != -1) {
//                return dp[cnt][r];
//            }
//            int res = Integer.MAX_VALUE;
//            for (int l = cnt; l <= r; l++) {
//                res = Math.min(res, dfs(s, l - 1, cnt - 1, dp) + getChageCnt(s, l, r));
//            }
//            return dp[cnt][r] = res;
//        }
//
//    }

//    class Solution {
//        public long continuousSubarrays(int[] nums) {
//            int n = nums.length;
//            TreeMap<Integer, Integer> map = new TreeMap<>();
//            long ans = 0L;
//            for (int left = 0, right = 0; right < n; right++) {
//                map.put(nums[right], map.getOrDefault(nums[right], 0) + 1);
//                while (map.lastKey() - map.firstKey() > 2) {
//                    int y = nums[left++];
//                    if (map.get(y) == 1) {
//                        map.remove(nums[left]);
//                    } else {
//                        map.put(y,map.get(nums[left]) - 1);
//                    }
//                    ans += right - left + 1;
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int largestInteger(int[] nums, int k) {
//            Map<Integer, List<Integer>> map = new HashMap<>();
//            for (int i = 0; i < nums.length; i++) {
//                map.computeIfAbsent(nums[i], key -> new ArrayList<>()).add(i);
//            }
//            int ans = -1;
//            for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
//                int x = entry.getKey();
//                List<Integer> positions = entry.getValue();
//                if (positions.size() != k) {
//                    continue;
//                }
//
//                boolean isConsecutive = true;
//                for (int i = 1; i < positions.size(); i++) {
//                    if (positions.get(i) != positions.get(i - 1) + 1) {
//                        isConsecutive = false;
//                        break;
//                    }
//                }
//                if (isConsecutive) {
//                    ans = Math.max(ans, x);
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        private final List<List<String>> ans = new ArrayList<>();
//        private final List<String> path = new ArrayList<>();
//        private String s;
//        public List<List<String>> partition(String s) {
//            this.s = s;
//            dfs(0, 0);
//            return ans;
//        }
//        private boolean isPalindrome(int left, int right) {
//            while (left < right)
//                if (s.charAt(left++) != s.charAt(right--))
//                    return false;
//            return true;
//        }
//
//        private void dfs(int i, int start) {
//            if (i == s.length()) {
//                ans.add(new ArrayList<>(path));
//                return;
//            }
//            if (i < s.length() - 1)
//                dfs(i + 1, start);
//            if (isPalindrome(start, i)) {
//                path.add(s.substring(start, i + 1));
//                dfs(i + 1, i + 1);
//                path.remove(path.size() - 1);
//            }
//        }
//    }

//    class Solution {
//        public boolean isPalindrome(ListNode head) {
//            Stack<ListNode> st = new Stack<>();
//            ListNode cur = head;
//            while (cur != null) {
//                st.add(cur);
//            }
//            cur = head;
//            while (cur != null) {
//                if (st.peek().val != cur.val) {
//                    return false;
//                }
//                st.pop();
//            }
//            return true;
//        }
//    }

//    class Solution {
//        public static Map<Integer, Integer> map = new HashMap<>();
//
//        public int[] twoSum(int[] nums, int target) {
//            map.clear();
//            for (int i = 0; i < nums.length; i++) {
//                if (map.containsKey(target - nums[i])) {
//                    return new int[]{i, map.get(target - nums[i])};
//                }
//                map.put(nums[i], i);
//            }
//            return new int[]{-1, -1};
//        }
//    }

//    class Solution {
//        public static final int[] monthArr = new int[]{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
//
//        public static int getDay(int year, int month, int day) {
//            int yearDay = getYearDay(year);
//            int monthDay = getMonthDay(year, month);
//            return yearDay + monthDay + day;
//        }
//
//        public static int getMonthDay(int year, int month) {
//            int sum = 0;
//            for (int i = 1; i < month; i++) {
//                if (isRunYear(year) && i == 2) {
//                    sum += 29;
//                } else {
//                    sum += monthArr[i];
//                }
//            }
//            return sum;
//        }
//
//        public static int getYearDay(int year) {
//            int sum = 0;
//            for (int i = 0; i < year; i++) {
//                if (isRunYear(i)) {
//                    sum += 366;
//                } else {
//                    sum += 365;
//                }
//            }
//            return sum;
//        }
//
//        public static boolean isRunYear(int year) {
//            if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
//                return true;
//            }
//            return false;
//        }
//
//        public int daysBetweenDates(String date1, String date2) {
//            int startYear = Integer.parseInt(new String(date1.substring(0, 4)));
//            int startMonth = Integer.parseInt(new String(date1.substring(5, 7)));
//            int startDay = Integer.parseInt(new String(date1.substring(8, 10)));
//            int endYear = Integer.parseInt(new String(date2.substring(0, 4)));
//            int endMonth = Integer.parseInt(new String(date2.substring(5, 7)));
//            int endDay = Integer.parseInt(new String(date2.substring(8, 10)));
//            System.out.println("start year is " + startYear + " start month is " + startMonth + " start day is " + startDay);
//            System.out.println("end year is " + endYear + " end month is " + endMonth + " end day is " + endDay);
//            return Math.abs(getDay(endYear, endMonth, endDay) - getDay(startYear, startMonth, startDay));
//        }
//    }

//    class FoodRatings {
//
//        class Food {
//            String food;
//            int rate;
//            String cuisine;
//
//            public Food(String foodName, String cuisine, int rate) {
//                food = foodName;
//                this.cuisine = cuisine;
//                this.rate = rate;
//            }
//        }
//
//        public static HashMap<String, TreeSet<Food>> flavorMap = new HashMap<>();
//        public static HashMap<String, Food> foodMap = new HashMap<>();
//
//        public FoodRatings(String[] foods, String[] cuisines, int[] ratings) {
//            int n = foods.length;
//            for (int i = 0; i < n; i++) {
//                String f = foods[i];
//                String c = cuisines[i];
//                int rate = ratings[i];
//                TreeSet<Food> set = flavorMap.getOrDefault(c,new TreeSet<>(new Comparator<Food>() {
//                            @Override
//                            public int compare(Food x, Food y) {
//                                return x.rate != y.rate ? y.rate - x.rate : x.food.compareTo(y.food);
//
//                            }
//                        }));
//                Food food = new Food(f, c, rate);
//                foodMap.put(f, food);
//                set.add(food);
//                flavorMap.put(c, set);
//            }
//        }
//
//        public void changeRating(String foodName, int newRating) {
//            Food tmp = foodMap.get(foodName);
//            TreeSet<Food> foods = flavorMap.get(tmp.cuisine);
//            foods.remove(tmp);
//            Food food = new Food(foodName, tmp.cuisine, newRating);
//            foodMap.put(foodName, food);
//            foods.add(food);
//        }
//
//        public String highestRated(String c) {
//            TreeSet<Food> foods = flavorMap.get(c);
//            return foods.first().food;
//        }
//    }

//    class TextEditor {
//
//        public static final int MAX_N = 20010;
//
//        public static Character[] left = new Character[MAX_N];
//
//        public static int leftR;
//
//        public static Character[] right = new Character[MAX_N];
//
//        public static int rightR;
//
//        TextEditor() {
//            leftR = rightR = 0;
//        }
//
//        public void addText(String text) {
//            char[] texts = text.toCharArray();
//            for (char c : texts) {
//                left[leftR++] = c;
//            }
//        }
//
//        public int deleteText(int k) {
//            k = Math.min(k, leftR - 1);
//            leftR = leftR - 1 - k;
//            return k;
//        }
//
//        public String cursorLeft(int k) {
//            while (k > 0 && leftR != 0) {
//                right[rightR++] = left[--leftR];
//                k--;
//            }
//            return get10Text();
//        }
//
//        public String cursorRight(int k) {
//            while (k > 0 && rightR != 0) {
//                left[leftR++] = right[--rightR];
//                k--;
//            }
//            return get10Text();
//        }
//
//        private String get10Text() {
//            StringBuilder sb = new StringBuilder();
//            int start = Math.max(leftR - 1 - 10, 0);
//            for (int i = start; i < leftR - 1; i++) {
//                sb.append(left[i]);
//            }
//            return sb.toString();
//        }
//    }


//    class TextEditor2 {
//        private final StringBuilder left = new StringBuilder();
//        private final StringBuilder right = new StringBuilder();
//
//        public void addText(String text) {
//            left.append(text);
//        }
//
//        public int deleteText(int k) {
//            k = Math.min(k, left.length());
//            left.setLength(left.length() - k);
//            return k;
//        }
//
//        public String cursorLeft(int k) {
//            while (k > 0 && !left.isEmpty()) {
//                right.append(left.charAt(left.length()) - 1);
//                left.setLength(left.length() - 1);
//                k--;
//            }
//            return text();
//        }
//
//        public String cursorRight(int k) {
//            while (k > 0 && !right.isEmpty()) {
//                left.append(right.charAt(right.length() - 1));
//                right.setLength(right.length() - 1);
//                k--;
//            }
//            return text();
//        }
//
//        private String text() {
//            return left.substring(Math.max(left.length() - 10, 0));
//        }
//    }

//    class BrowserHistory {
//        public static final int MAX_N = 5010;
//
//        public static String[] st = new String[MAX_N];
//
//        public static int r;
//
//        public static int cur;
//
//        public BrowserHistory(String homepage) {
//            r = cur = 0;
//            st[r++] = homepage;
//        }
//
//        public void visit(String url) {
//            r = ++cur;
//            st[r++] = url;
//        }
//
//        public String back(int steps) {
//            steps = Math.min(steps, cur);
//            cur -= steps;
//            return st[cur];
//        }
//
//        public String forward(int steps) {
//            cur = cur + steps < r ? cur + steps : r - 1;
//            return st[cur];
//        }
//    }

//    class Allocator {
//        private final int[] memory;
//
//        public Allocator(int n) {
//            memory = new int[n];
//        }
//
//        public int allocate(int size, int mID) {
//            int free = 0;
//            for (int i = 0; i < memory.length; i++) {
//                if (memory[i] > 0) {
//                    free = 0;
//                    continue;
//                }
//                free++;
//                if (free == size) {
//                    Arrays.fill(memory, i - size + 1, i + 1, mID);
//                    return i - size + 1;
//                }
//            }
//            return -1;
//        }
//
//        public int freeMemory(int mID) {
//            int ans = 0;
//            for (int i = 0; i < memory.length; i++) {
//                if (memory[i] == mID) {
//                    ans++;
//                    memory[i] = 0;
//                }
//            }
//            return ans;
//        }
//    }

//    class Solution {
//        public int maxDistance(int side, int[][] points, int k) {
//            List<Integer> list = new ArrayList<>();
//            for (int[] p : points) {
//                int x = p[0], y = p[1];
//                if (x == 0) {
//                    list.add(y);
//                } else if (y == side) {
//                    list.add(side + x);
//                } else if (x == side) {
//                    list.add(3 * side - y);
//                } else if (y == 0) {
//                    list.add(4 * side - x);
//                }
//            }
//            Collections.sort(list);
//            int n = list.size();
//            if (n < k) {
//                return 0;
//            }
//            int L = 4 * side;
//            int left = 0, right = 2 * side;
//            int ans = 0;
//            while (left <= right) {
//                int mid = (left + right) / 2;
//                if (canSelect(list, k, mid, L)) {
//                    ans = mid;
//                    left = mid + 1;
//                } else {
//                    right = mid - 1;
//                }
//            }
//            return ans;
//        }
//
//        private boolean canSelect(List<Integer> list, int k, int d, int L) {
//            int n = list.size();
//            int count1 = 0;
//            int last = -1;
//            for (int i = 0; i < n; i++) {
//                if (last == -1 || list.get(i) - last >= d) {
//                    count1++;
//                    last = list.get(i);
//                }
//            }
//            if (count1 >= k) {
//                return true;
//            }
//            int count2 = 1;
//            last = list.get(0);
//            for (int i = 1; i < n; i++) {
//                if (list.get(i) - last >= d) {
//                    count2++;
//                    last = list.get(i);
//                }
//            }
//            if (count2 >= k) {
//                int first = list.get(0);
//                int delta = last - first;
//                int ringDistance = Math.min(delta, L - delta);
//                if (ringDistance >= d) {
//                    return true;
//                }
//            }
//            return false;
//        }
//    }

//    class Skiplist {
//
//        public static int MAXL = 10;
//
//        public static int MAXN = 50010;
//
//        public static int cnt;
//
//        public static int[] key = new int[MAXN];
//
//        public static int[] count = new int[MAXN];
//
//        public static int[] level = new int[MAXN];
//
//        public static int[][] next = new int[MAXN][MAXL + 1];
//
//        public static int[][] len = new int[MAXN][MAXL + 1];
//
//        public static void build() {
//            cnt = 1;
//            key[cnt] = Integer.MIN_VALUE;
//            level[cnt] = MAXL;
//        }
//
//        public static void clear() {
//            Arrays.fill(key, 1, cnt + 1, 0);
//            Arrays.fill(count, 1, cnt + 1, 0);
//            Arrays.fill(level, 1, cnt + 1, 0);
//            for (int i = 1; i <= cnt; i++) {
//                Arrays.fill(next[i], 0);
//                Arrays.fill(len[i], 0);
//            }
//            cnt = 0;
//        }
//
//        public static int random() {
//            int ans = 1;
//            while (Math.random() < 0.5) {
//                ans++;
//            }
//            return Math.min(ans, MAXL);
//        }
//
//        public static int find(int i, int h, int num) {
//            while (next[i][h] != 0 && key[next[i][h]] < num) {
//                i = next[i][h];
//            }
//            if (h == 1) {
//                if (next[i][h] != 0 && key[next[i][h]] == num) {
//                    return next[i][h];
//                } else {
//                    return 0;
//                }
//            }
//            return find(i, h - 1, num);
//        }
//
//        public static void addInSkip(int num) {
//            if (find(1, MAXL, num) != 0) {
//                addCount(1, MAXL, num);
//            } else {
//                key[++cnt] = num;
//                count[cnt] = 1;
//                level[cnt] = random();
//                addNode(1, MAXL, cnt);
//            }
//        }
//
//        public static void addCount(int i, int h, int num) {
//            while (next[i][h] != 0 && key[next[i][h]] < num) {
//                i = next[i][h];
//            }
//            if (h == 1) {
//                count[next[i][h]]++;
//            } else {
//                addCount(i, h - 1, num);
//            }
//            len[i][h]++;
//        }
//
//        public static int addNode(int i, int h, int j) {
//            int rightCnt = 0;
//            while (next[i][h] != 0 && key[next[i][h]] < key[j]) {
//                rightCnt += len[i][h];
//                i = next[i][h];
//            }
//            if (h == 1) {
//                next[j][h] = next[i][h];
//                next[i][h] = j;
//                len[j][h] = count[next[j][h]];
//                len[i][h] = count[next[i][h]];
//                return rightCnt;
//            } else {
//                int downCnt = addNode(i, h - 1, j);
//                if (h > level[j]) {
//                    len[i][h]++;
//                } else {
//                    next[j][h] = next[i][h];
//                    next[i][h] = j;
//                    len[j][h] = len[i][h] + 1 - downCnt - count[j];
//                    len[i][h] = downCnt + count[j];
//                }
//                return rightCnt + downCnt;
//            }
//        }
//
//        public static void remove(int num) {
//            int j = find(1, MAXL, num);
//            if (j != 0) {
//                if (count[j] > 1) {
//                    removeCount(1, MAXL, num);
//                } else {
//                    removeNode(1, MAXL, j);
//                }
//            }
//        }
//
//        public static void removeCount(int i, int h, int num) {
//            while (next[i][h] != 0 && key[next[i][h]] < num) {
//                i = next[i][h];
//            }
//            if (h == 1) {
//                count[next[i][h]]--;
//            } else {
//                removeCount(i, h - 1, num);
//            }
//            len[i][h]--;
//        }
//
//        public static void removeNode(int i, int h, int j) {
//            if (h < 1) {
//                return;
//            }
//            while (next[i][h] != 0 && key[next[i][h]] < key[j]) {
//                i = next[i][h];
//            }
//            if (h > level[j]) {
//                len[i][h]--;
//            } else {
//                next[i][h] = next[j][h];
//                len[i][h] += len[j][h] - 1;
//            }
//            removeNode(i, h - 1, j);
//        }
//
//        public Skiplist() {
//            clear();
//            build();
//        }
//
//        public boolean search(int target) {
//            if (find(1, MAXL, target) == 0) return false;
//            return true;
//        }
//
//        public void add(int num) {
//            addInSkip(num);
//        }
//
//        public boolean erase(int num) {
//            if (search(num) == false) return false;
//            remove(num);
//            return true;
//        }
//    }

//    class Solution5 {
//        public int findMagicIndex(int[] nums) {
//            int n = nums.length;
//            return dfs(nums, 0, nums.length - 1);
//        }
//
//        public int dfs(int[] nums, int left, int right) {
//            if (left > right) {
//                return -1;
//            }
//            int mid = (right - left) / 2 + left;
//            int leftAnswer = dfs(nums, left, mid - 1);
//            if (leftAnswer != -1) {
//                return leftAnswer;
//            } else if (nums[mid] == mid) {
//                return mid;
//            }
//            return dfs(nums, mid + 1, right);
//        }
//    }

//    class Solution4 {
//        public int similarPairs(String[] words) {
//            Map<Integer, Integer> cnt = new HashMap<>();
//            int ans = 0;
//            for (String s : words) {
//                int mask = 0;
//                for (char c : s.toCharArray()) {
//                    mask |= 1 << (c - 'a');
//                }
//                int c = cnt.getOrDefault(mask, 0);
//                ans += c;
//                cnt.put(mask, c + 1);
//            }
//            return ans;
//        }
//    }

//    class Solution3 {
//        private Integer[][] dp;
//        private int[] s;
//        private int n;
//        private int k;
//
//        public int minimumWhiteTiles(String floor, int numCarpets, int carpetLen) {
//            n = floor.length();
//            dp = new Integer[n][numCarpets + 1];
//            s = new int[n + 1];
//            for (int i = 0; i < n; ++i) {
//                s[i + 1] = s[i] + (floor.charAt(i) == '1' ? 1 : 0);
//            }
//            k = carpetLen;
//            return dfs(0, numCarpets);
//        }
//
//        private int dfs(int i, int j) {
//            if (i >= n) {
//                return 0;
//            }
//            if (j == 0) {
//                return s[n] - s[i];
//            }
//            if (dp[i][j] != null) {
//                return dp[i][j];
//            }
//            if (s[i + 1] == s[i]) {
//                return dfs(i + 1, j);
//            }
//            int ans = Math.min(1 + dfs(i + 1, j), dfs(i + k, j - 1));
//            dp[i][j] = ans;
//            return ans;
//        }
//    }

//    class Solution10 {
//        public int minimumWhiteTiles(String floor, int numCarpets, int carpetLen) {
//            int m = floor.length();
//            if (numCarpets * carpetLen >= m) {
//                return 0;
//            }
//
//            char[] s = floor.toCharArray();
//            int[] dp = new int[m];
//            dp[0] = s[0] - '0';
//            for (int j = 1; j < m; j++) {
//                dp[j] = dp[j - 1] + (s[j] - '0');
//            }
//            for (int i = 1; i <= numCarpets; i++) {
//                int[] next = new int[m];
//                for (int j = carpetLen * i; j < m; j++) {
//                    next[j] = Math.min(next[j - 1] + (s[j] - '0'), dp[j - carpetLen]);
//                }
//                dp = next;
//            }
//            return dp[m - 1];
//        }
//    }

//    class Solution2 {
//        public int minimumWhiteTiles(String floor, int numCarpets, int carpetLen) {
//            char[] s = floor.toCharArray();
//            int m = s.length;
//            int[][] dp = new int[numCarpets + 1][m];
//            dp[0][0] = s[0] - '0';
//            for (int j = 1; j < m; j++) {
//                dp[0][j] = dp[0][j - 1] + (s[j] - '0');
//            }
//            for (int i = 1; i <= numCarpets; i++) {
//                for (int j = carpetLen * i; j < m; j++) {
//                    dp[i][j] = Math.min(dp[i][j - 1] + (s[j] - '0'), dp[i - 1][j - carpetLen]);
//                }
//            }
//            return dp[numCarpets][m - 1];
//        }
//    }

//    class Solution1 {
//        public int minimumWhiteTiles(String floor, int numCarpets, int carpetLen) {
//            int m = floor.length();
//            int[][] dp = new int[numCarpets + 1][m];
//            for (int[] row : dp) {
//                Arrays.fill(row, -1);
//            }
//            return dfs(numCarpets, m - 1, floor.toCharArray(), dp, carpetLen);
//        }
//
//        private int dfs(int i, int j, char[] floor, int[][] dp, int carpetLen) {
//            if (j < carpetLen * i) {
//                return 0;
//            }
//            if (dp[i][j] != -1) {
//                return dp[i][j];
//            }
//            int res = dfs(i, j - 1, floor, dp, carpetLen) + (floor[j] - '0');
//            if (i > 0) {
//                res = Math.min(res, dfs(i - 1, j - carpetLen, floor, dp, carpetLen));
//            }
//            return dp[i][j] = res;
//        }
//    }


//    public String reverseStr(String s, int k) {
//        char[] str = s.toCharArray();
//        int pre = 0;
//        for (int i = 0; i < str.length; i += 2 * k) {
//            if (str.length - i < k) {
//                reverse(str, i, str.length - 1);
//            } else {
//                reverse(str, i, i + k);
//            }
//        }
//        return Arrays.toString(str);
//    }

//    public static void reverse(char[] str, int left, int right) {
//        while (left < right) {
//            char tmp = str[left];
//            str[left] = str[right];
//            str[right] = tmp;
//            left++;
//            right--;
//        }
//    }


//    public static Set<Integer> st = new HashSet<>();

//    public int[] intersection(int[] nums1, int[] nums2) {
//        st.clear();
//        for (int x : nums1) {
//            st.add(x);
//        }
//        for (int x : nums2) {
//            if (!st.contains(x)) {
//                st.remove(x);
//            }
//        }
//        List<Integer> collect = st.stream().collect(Collectors.toList());
//        int[] ret = new int[collect.size()];
//        for (int i = 0; i < ret.length; i++) {
//            ret[i] = collect.get(i);
//        }
//        return ret;
//    }

//    class Solution {
//
//        public static ListNode findEnd(ListNode s, int step) {
//            while (s.next != null && step-- > 0) {
//                s = s.next;
//            }
//            return s;
//        }
//
//        public static ListNode start;
//
//        public static ListNode end;
//
//        public static void merge(ListNode l1, ListNode r1, ListNode l2, ListNode r2) {
//            ListNode pre;
//            if (l1.val <= l2.val) {
//                start = l1;
//                pre = l1;
//                l1 = l1.next;
//            } else {
//                start = l2;
//                pre = l2;
//                l2 = l2.next;
//            }
//            while (l1 != null && l2 != null) {
//                if (l1.val <= l2.val) {
//                    pre.next = l1;
//                    pre = l1;
//                    l1 = l1.next;
//                } else {
//                    pre.next = l2;
//                    pre = l2;
//                    l2 = l2.next;
//                }
//            }
//            if (l1 != null) {
//                pre.next = l1;
//                end = r1;
//            } else {
//                pre.next = l2;
//                end = r2;
//            }
//        }
//
//        public ListNode sortList(ListNode head) {
//            int n = 0;
//            ListNode cur = head;
//            while (cur != null) {
//                cur = cur.next;
//                n++;
//            }
//            ListNode l1, r1, l2, r2, next, lastTeamEnd;
//            for (int step = 1; step < n; step <<= 1) {
//                l1 = head;
//                r1 = findEnd(l1, step);
//                l2 = r1.next;
//                r2 = findEnd(l2, step);
//                next = r2.next;
//                merge(l1,r1,l2,r2);
//                lastTeamEnd = end;
//                while(next != null){
//                    l1 = lastTeamEnd;
//                    r1 = findEnd(l1,step);
//                    l2 = r1.next;
//                    if(l2 == null){
//                        lastTeamEnd = r1;
//                        break;
//                    }
//                    r2 = findEnd(l2,step);
//                    merge(l1,r1,l2,r2);
//                    lastTeamEnd.next = start;
//                    lastTeamEnd =end;
//                }
//            }
//            return head;
//        }
//    }

//    class Solution {
//        public int minOperations(int[] nums, int k) {
//            PriorityQueue<Integer> pq = new PriorityQueue<>();
//            for (int num : nums) {
//                pq.add(num);
//            }
//            int ans = 0;
//            int x = 0;
//            int y = 0;
//            while (true) {
//                x = pq.poll();
//                System.out.println("x = " + x);
//                if (x >= k || pq.isEmpty()) {
//                    break;
//                }
//                y = pq.poll();
//                System.out.println("y = " + y);
//                int ret = Math.min(x, y) * 2 + Math.max(x, y);
//                ans++;
//                pq.add(ret);
//            }
//            return ans;
//        }
//    }
//    class Solution {
//        public static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
//
//
//        public int orangesRotting(int[][] grid) {
//            int m = grid.length;
//            int n = grid[0].length;
//            int fresh = 0;
//            List<int[]> que = new ArrayList<>();
//            for (int i = 0; i < m; i++) {
//                for (int j = 0; j < n; j++) {
//                    if (grid[i][j] == 1) {
//                        fresh++;
//                    } else if (grid[i][j] == 2) {
//                        que.add(new int[]{i, j});
//                    }
//                }
//            }
//
//            int ans = 0;
//            while (fresh > 0 && !que.isEmpty()) {
//                ans++;
//                List<int[]> tmp = que;
//                que = new ArrayList<>();
//                for (int[] pos : tmp) {
//                    for (int[] dir : DIRECTIONS) {
//                        int i = pos[0] + dir[0];
//                        int j = pos[1] + dir[1];
//                        if (0 <= i && i < m && 0 <= j && j < n && grid[i][j] == 1) {
//                            fresh--;
//                            grid[i][j] = 2;
//                            que.add(new int[]{i, j});
//                        }
//                    }
//                }
//            }
//            return fresh > 0 ? -1 : ans;
//        }
//    }
//
//
//    class Solution {
//
//        public static final int SIZE = 8;
//        private static final int[][] DIRS = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
//
//        public int numRookCaptures(char[][] board) {
//            int rX = 0;
//            int rY = 0;
//            for (int i = 0; i < SIZE; i++) {
//                for (int j = 0; j < SIZE; j++) {
//                    if (board[i][j] == 'R') {
//                        rX = i;
//                        rY = j;
//                    }
//                }
//            }
//            int ans = 0;
//            for (int[] d : DIRS) {
//                int x = rX + d[0];
//                int y = rY + d[1];
//                while (0 <= x && x < SIZE && 0 <= y && y < SIZE && board[x][y] == '.') {
//                    x += d[0];
//                    y += d[1];
//                }
//                if (0 <= x && x < SIZE && 0 <= y && y < SIZE && board[x][y] == 'p') {
//                    ans++;
//                }
//            }
//            return ans;
//        }
//    }
//
//
//    class Solution {
//
//        private boolean judgeMid(int l, int m, int r) {
//            return Math.min(l, r) < m && m < Math.max(l, r);
//        }
//
//        public int minMovesToCaptureTheQueen(int a, int b, int c, int d, int e, int f) {
//            if (a == e && (c != e || !judgeMid(b, d, f)) ||
//                    b == f && (d != f || !judgeMid(a, c, e)) ||
//                    c + d == e + f && (a + b != e + f || !judgeMid(c, a, e)) ||
//                    c - d == e - f && (a - b != e - f || !judgeMid(c, a, e))) {
//                return 1;
//            }
//            return 2;
//        }
//    }
//
//    class Solution {
//
//        public static int MAX_N = 4;
//        public static int[][] dirs = {{0, 0}, {-1, 0}, {1, 0}, {0, -1}, {0, 1}, {-1, -1}, {1, 1}, {-1, 1}, {1, -1}};
//
//        public int[] getDirIndicesRange(String piece) {
//            if ("queen".equals(piece)) {
//                return new int[]{1, 8};
//            } else if ("rook".equals(piece)) {
//                return new int[]{1, 4};
//            } else {
//                return new int[]{5, 8};
//            }
//        }
//
//        public boolean isValid(int row, int column) {
//            return row >= 1 && row <= SIDE && column >= 1 && column <= SIDE;
//        }
//
//        public static int n;
//        public static final int SIDE = 8;
//        public static String[] pieces;
//        public static int[][] positions;
//        public static int[][][] board = new int[MAX_N][SIDE][SIDE];
//
//        public void build(String[] pie, int[][] pos) {
//            n = pie.length;
//            pieces = pie;
//            positions = pos;
//            for (int i = 0; i < n; i++) {
//                for (int j = 0; j <= SIDE; j++) {
//                    Arrays.fill(board[i][j], -1);
//                }
//            }
//        }
//
//        public int countCombinations(String[] pieces, int[][] positions) {
//            build(pieces, positions);
//            return backtrack(0);
//        }
//
//        public static final int STOP_VALUE = 100;
//
//        public int backtrack(int index) {
//            if (index == n) {
//                return 1;
//            }
//            int count = 0;
//            int startRow = positions[index][0], startColumn = positions[index][1];
//            String piece = pieces[index];
//            int[] dirIndicesRange = getDirIndicesRange(piece);
//            for (int i = 0; i <= 8; i++) {
//                if (i != 0 && (i < dirIndicesRange[0] || i > dirIndicesRange[1])) {
//                    continue;
//                }
//                int[] dir = dirs[i];
//                boolean blocked = false;
//                int row = startRow + dir[0];
//                int column = startColumn + dir[1];
//                int steps = 1;
//                while (!blocked && isValid(row, column)) {
//                    boolean canStop = true;
//                    for (int prevIndex = 0; prevIndex < index; prevIndex++) {
//                        if (canStop) {
//                            canStop = board[prevIndex][row][column] < steps;
//                        }
//                        if (!blocked) {
//                            blocked = (board[prevIndex][row][column] >= STOP_VALUE && board[prevIndex][row][column] - STOP_VALUE <= steps) || board[prevIndex][row][column] == steps;
//                        }
//                    }
//                    if (canStop) {
//                        board[index][row][column] = STOP_VALUE + steps;
//                        count += backtrack(index + 1);
//                    }
//                    board[index][row][column] = steps;
//                    if (i == 0) {
//                        break;
//                    }
//                    row += dir[0];
//                    column += dir[1];
//                    steps++;
//                }
//                for (int j = 0; j <= SIDE; j++) {
//                    Arrays.fill(board[index][j], -1);
//                }
//            }
//            return count;
//        }
//    }
//
//    class Solution {
//        public static int n;
//        public static int[] nums;
//
//        public int snakesAndLadders(int[][] board) {
//            n = board.length;
//            if (board[0][0] != -1) return -1;
//            nums = new int[n * n + 1];
//            boolean isRight = true;
//            for (int i = n - 1, idx = 1; i >= 0; i--) {
//                for (int j = (isRight ? 0 : n - 1); isRight ? j < n : j >= 0; j += isRight ? 1 : -1) {
//                    nums[idx++] = board[i][j];
//                }
//                isRight = !isRight;
//            }
//            int ans = bfs();
//            return ans;
//        }
//
//        private static int bfs() {
//            Deque<Integer> d = new ArrayDeque<>();
//            Map<Integer, Integer> m = new HashMap<>();
//            d.addLast(1);
//            m.put(1, 0);
//            while (!d.isEmpty()) {
//                int poll = d.pollFirst();
//                int step = m.get(poll);
//                if (poll == n * n) return step;
//                for (int i = 1; i <= 6; i++) {
//                    int np = poll + i;
//                    if (np <= 0 || np > n * n) continue;
//                    if (nums[np] != -1) np = nums[np];
//                    if (m.containsKey(np)) continue;
//                    m.put(np, step + 1);
//                    d.addLast(np);
//                }
//            }
//            return -1;
//        }
//    }
//
//    public boolean canAliceWin(int[] nums) {
//        int first = 0;
//        int sum = 0;
//        for (int i = 0; i < nums.length; i++) {
//            if (nums[i] < 10) {
//                first += nums[i];
//            } else {
//                sum += nums[i];
//            }
//        }
//        return first == sum;
//    }
//
//
//    public static final int MOD = 1000000007;
//
//    public static long[][] dp;
//
//    public static long[] preSum;

//    public int countOfPairs(int[] nums) {
//        int n = nums.length;
//        int m = Integer.MIN_VALUE;
//        for (int i = 0; i < nums.length; i++) {
//            m = nums[i] > m ? nums[i] : m;
//        }
//        dp = new long[n][m + 1];
//        preSum = new long[m + 1];
//
//        Arrays.fill(dp[0], 0, nums[0] + 1, 1);
//        for (int i = 1; i < n; i++) {
//            preSum[0] = dp[i - 1][0];
//            for (int k = 1; k <= m; k++) {
//                preSum[k] = (preSum[k - 1] + dp[i - 1][k]) % MOD;
//            }
//            for (int j = 0; j <= nums[i]; j++) {
//                int maxK = j + Math.min(nums[i - 1] - nums[i], 0);
//                dp[i][j] = maxK >= 0 ? preSum[maxK] % MOD : 0;
//            }
//        }
//        long sum = 0;
//        for (int i = 0; i <= nums[n - 1]; i++) {
//            sum = (sum + dp[n - 1][i]) % MOD;
//        }
//        return (int) sum;
//        // return (int) (Arrays.stream(dp[n - 1], 0, nums[n - 1] + 1).sum() % MOD);
//    }

//    public int minArraySum(int[] nums, int k, int op1, int op2) {
//        int n = nums.length;
//        for (int i = 0; i < n; i++) {
//            if (nums[i] == k && op2 != 0) {
//                nums[i] = 0;
//                op2--;
//            }
//        }
//        Arrays.sort(nums);
//        for (int i = n - 1; i >= 0; i--) {
//            if (op2 != 0 && nums[i] >= k) {
//                System.out.println("nums[i]:" + nums[i]);
//                int first = nums[i] - (nums[i] + 1) / 2;
//                int second = k;
//                int third1 = 0;
//                if (nums[i] - first >= k) {
//                    third1 = first + k;
//                } else {
//                    third1 = first;
//                }
//                int third2 = k + ((nums[i] + 1) / 2 + 1) / 2;
//                int third = Math.max(third2, third1);
//                System.out.println("first" + first + "second" + second + "third" + third);
//                if (op1 != 0 && op2 != 0 && third > first && third > second) {
//                    nums[i] -= third;
//                    op1--;
//                    op2--;
//                } else if (op1 != 0 && first > second) {
//                    System.out.println(1);
//                    nums[i] = (nums[i] + 1) / 2;
//                    System.out.println("1后的nums[i]:" + nums[i]);
//                    op1--;
//                } else {
//                    System.out.println(2);
//                    nums[i] = nums[i] - k;
//                    op2--;
//                }
//            } else {
//                if (op1 != 0) {
//                    nums[i] = (nums[i] + 1) / 2;
//                    op1--;
//                }
//            }
//        }
//        int sum = 0;
//        for (int i = 0; i < n; i++) {
//            sum += nums[i];
//        }
//        return sum;
//    }

//    class Solution {
//        public int minimumSumSubarray(List<Integer> nums, int l, int r) {
//            return minSubarraySum(nums, l, r);
//        }
//
//        public static int minSubarraySum(List<Integer> nums, int l, int r) {
//            int n = nums.size();
//            int minSum = Integer.MAX_VALUE;
//            boolean found = false;
//
//            for (int i = 0; i < n; i++) {
//                int currentSum = 0;
//                for (int j = i; j < n; j++) {
//                    currentSum += nums.get(j);
//                    int length = j - i + 1;
//                    if (length >= l && length <= r && currentSum > 0) {
//                        minSum = Math.min(minSum, currentSum);
//                        found = true;
//                    }
//                }
//            }
//
//            return found ? minSum : -1;
//        }
//    }
//
//    public static int MAX_N = 100005;
//
//    public static long[] arr = new long[MAX_N];
//    public static long[] max = new long[MAX_N << 2];
//    public static long[] add = new long[MAX_N << 2];
//
//    public static void up(int i) {
//        max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
//    }
//
//    public static void lazy(int i, long v) {
//        max[i] += v;
//        add[i] += v;
//    }
//
//    public static void down(int i) {
//        if (add[i] != 0) {
//            lazy(i << 1, add[i]);
//            lazy(i << 1 | 1, add[i]);
//            add[i] = 0;
//        }
//    }
//
//    public static void build(int l, int r, int i) {
//        if (l == r) {
//            max[i] = arr[l];
//        } else {
//            int mid = (l + r) >> 1;
//            build(l, mid, i << 1);
//            build(mid + 1, r, i << 1 | 1);
//            up(i);
//        }
//        add[i] = 0;
//    }
//
//    public static void add(int jobl, int jobr, long jobv, int l, int r, int i) {
//        if (jobl <= l && r <= jobr) {
//            lazy(i, jobv);
//        } else {
//            int mid = (l + r) >> 1;
//            down(i);
//            if (jobl <= mid) {
//                add(jobl, jobr, jobv, l, mid, i << 1);
//            }
//            if (jobr > mid) {
//                add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
//            }
//            up(i);
//        }
//    }
//
//    public static long query(int jobl, int jobr, int l, int r, int i) {
//        if (jobl <= l && r <= jobr) return max[i];
//        int mid = (l + r) >> 1;
//        down(i);
//        long ans = Long.MIN_VALUE;
//        if (jobl <= mid) ans = Math.max(ans, query(jobl, jobr, l, mid, i << 1));
//        if (jobr > mid) ans = Math.max(ans, query(jobl, jobr, mid + 1, r, (i << 1) + 1));
//        return ans;
//    }
//
//    public int minZeroArray(int[] nums, int[][] queries) {
//        int n = nums.length;
//        for (int i = 1; i <= n; i++) {
//            arr[i] = nums[i - 1];
//        }
//        build(1, n, 1);
//        if (max[1] == 0)
//            return 0;
//        int k = 0;
//        for (int i = 0; i < queries.length; i++) {
//            int l = queries[i][0] + 1;
//            int r = queries[i][1] + 1;
//            int v = queries[i][2];
//            add(l, r, -v, 1, n, 1);
//            if (query(1, n, 1, n, 1) < 0) {
//                return i + 1;
//            }
//        }
//        return -1;
//    }
//
//    class Solution {
//        public static int MAX_N = 100005;
//        public static int[] father = new int[MAX_N];
//
//        public static int cnt;
//
//        public static int total;
//
//        public static void build(int n) {
//            for (int i = 1; i <= n; i++) {
//                father[i] = i;
//            }
//            cnt = n;
//            total = n;
//        }
//
//        public static int find(int x) {
//            if (father[x] != x) {
//                father[x] = find(father[x]);
//            }
//            return father[x];
//        }
//
//        public static void clear() {
//            Arrays.fill(father, 0, total, 0);
//        }
//
//        public int[] shortestDistanceAfterQueries(int n, int[][] queries) {
//            build(n);
//            int[] ans = new int[queries.length];
//            for (int qi = 0; qi < queries.length; qi++) {
//                int l = queries[qi][0];
//                int r = queries[qi][1] - 1;
//                int fatherR = find(r);
//                for (int i = find(l); i < r; i = find(i + 1)) {
//                    father[i] = fatherR;
//                    cnt--;
//                }
//                ans[qi] = cnt;
//            }
//            clear();
//            return ans;
//        }
//    }
//
//    public class TreeNode {
//        int val;
//        TreeNode left;
//        TreeNode right;
//
//        TreeNode() {
//        }
//
//        TreeNode(int val) {
//            this.val = val;
//        }
//
//        TreeNode(int val, TreeNode left, TreeNode right) {
//            this.val = val;
//            this.left = left;
//            this.right = right;
//        }
//    }
//
//
//    class BSTIterator {
//
//        public static ArrayList<Integer> ans = new ArrayList<>();
//
//        public static int cur;
//
//        public BSTIterator(TreeNode root) {
//            ans.clear();
//            ans.add(Integer.MIN_VALUE);
//            inorder(root);
//            cur = 0;
//        }
//
//        public void inorder(TreeNode root) {
//            if (root == null) {
//                return;
//            }
//            inorder(root.left);
//            ans.add(root.val);
//            inorder(root.right);
//        }
//
//        public int next() {
//            return ans.get(++cur);
//        }
//
//        public boolean hasNext() {
//            if (cur != ans.size()) {
//                return true;
//            } else {
//                return false;
//            }
//        }
//    }
//
//    class Solution {
//
//        public static int MAX_N = 10005;
//
//        public static int[] isPrime = new int[MAX_N];
//
//        public static int result;
//
//        public static int maxVal;
//
//        public static int euler(int left,int right) {
//            for (int i = 2; i <= right; i++) {
//                if (isPrime[i] == 0) {
//                    isPrime[i] = isPrime[i - 1] + 1;
//                    for (int j = i * i; j <= right; j += i) {
//                        isPrime[j] = -1;
//                    }
//                } else {
//                    isPrime[i] = isPrime[i - 1];
//                }
//            }
//        }
//
//        public static void build(int n) {
//            result = 0;
//            maxVal = (int) Math.sqrt(n) + 1;
//            Arrays.fill(isPrime, 0, maxVal, true);
//        }
//
//        public int nonSpecialCount(int l, int r) {
//            return r - l + 1 - vis[(int)Math.sqrt(r)] + vis[(int)Math.ceil(Math.sqrt(l)) - 1];
//        }
//    }
//
//    public boolean isValidSudoku(char[][] board) {
//        Map<Integer, Set<Integer>> row = new HashMap<>();
//        Map<Integer, Set<Integer>> col = new HashMap<>();
//        Map<Integer, Set<Integer>> area = new HashMap<>();
//        for (int i = 0; i < 9; i++) {
//            row.put(i, new HashSet<>());
//            col.put(i, new HashSet<>());
//            area.put(i, new HashSet<>());
//        }
//        for (int i = 0; i < 9; i++) {
//            for (int j = 0; j < 9; j++) {
//                char c = board[i][j];
//                if (c == '.')
//                    continue;
//                int u = c - '0';
//                int idx = i / 3 * 3 + j / 3;
//                if (row.get(i).contains(u) || col.get(j).contains(u) || area.get(idx).contains(u))
//                    return false;
//                row.get(i).add(u);
//                col.get(j).add(u);
//                area.get(idx).add(u);
//            }
//        }
//        return true;
//    }
//
//    public boolean canConstruct(String ransomNote, String magazine) {
//        int[] map = new int[26];
//        for (int i = 0; i < magazine.length(); i++) {
//            char c = magazine.charAt(i);
//            map[i - 'a']++;
//        }
//        for (int i = 0; i < ransomNote.length(); i++) {
//            char c = ransomNote.charAt(i);
//            if (map[c - 'a'] == 0) {
//                return false;
//            }
//            map[i - 'a']--;
//        }
//        return true;
//    }
//
//
//    public int finalPositionOfSnake(int n, List<String> commands) {
//        int[][] grid = new int[n][n];
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < n; j++) {
//                grid[i][j] = i * n + j;
//            }
//        }
//        int x = 0;
//        int y = 0;
//        for (String command : commands) {
//            if (command.charAt(0) == 'U') {
//                x--;
//            } else if (command.charAt(0) == 'L') {
//                y++;
//            } else if (command.charAt(0) == 'D') {
//                x++;
//            }
//        }
//        return grid[x][y];
//    }
//
//
//    public String replaceSpaces(String S, int length) {
//        StringBuilder ret = new StringBuilder();
//        char[] s = S.toCharArray();
//        for (int i = 0; i < length; i++) {
//            if (s[i] != ' ') {
//                ret.append(s[i]);
//            } else {
//                ret.append("%20");
//            }
//        }
//        return ret.toString();
//    }
//
////
////    class MinStack {
////
////        public Stack<int[]> stack = new Stack<>();
////
////        public MinStack() {
////        stack.clear();
////        }
////
////        public void push(int val) {
////            if(stack.isEmpty()){
////                int[] temp = new int[2];
////                temp[0] = val;
////                temp[1] = val;
////                stack.push(temp);
////            }else {
////                int[] temp = new int[2];
////                temp[0] = val;
////                if(val < stack.peek()[1]){
////                    temp[1] = val;
////                }else {
////                    temp[1] = stack.peek()[1];
////                }
////                stack.push(temp);
////            }
////        }
////
////        public void pop() {
////            stack.pop();
////        }
////
////        public int top() {
////            return stack.peek()[0];
////        }
////
////        public int getMin() {
////        return stack.peek()[1];
////        }
////    }
////
////    public static int MAX_N = 205;
////
////    public static int[] father = new int[MAX_N];
////
////    public static int cnt;
////
////    public static void build(int n) {
////        for (int i = 0; i <= n; i++) {
////            father[i] = i;
////        }
////        cnt = n;
////    }
////
////    public static int find(int x) {
////        if (father[x] == x) {
////            father[x] = find(father[x]);
////        }
////        return father[x];
////    }
////
////    public static void union(int x, int y) {
////        int fx = find(x);
////        int fy = find(y);
////        if (fx != fy) {
////            father[fy] = fx;
////            cnt--;
////        }
////    }
////
////    public static boolean isSameSet(int x, int y) {
////        return find(x) == find(y);
////    }
////
////    public int findCircleNum(int[][] isConnected) {
////        int n = isConnected.length;
////        build(n);
////        for (int i = 0; i < n; i++) {
////            for (int j = 0; j < n; j++) {
////                if (isConnected[i][j] == 1) {
////                    union(i + 1, j + 1);
////                }
////            }
////        }
////        return cnt;
////    }
////
//////
//////    public static int ans;
//////
//////    public static int MAX_N = 100001;
//////
//////    public static int[] head = new int[MAX_N];
//////
//////    public static int[] next = new int[MAX_N];
//////
//////    public static int[] to = new int[MAX_N];
//////
//////    public static int cnt;
//////
//////
//////    public static void add(int u, int v) {
//////        next[cnt] = head[u];
//////        to[cnt] = v;
//////        head[u] = cnt++;
//////    }
//////
//////    public static int dfs(int curNode, int father) {
//////        int size = 1;
//////        int sonSize = 0;
//////        boolean flag = true;
//////        for (int ei = head[curNode]; ei > 0; ei = next[ei]) {
//////            int nextNode = to[ei];
//////            if (nextNode == father) {
//////                continue;
//////            }
//////            int sz = dfs(nextNode, curNode);
//////            if (sonSize == 0) {
//////                sonSize = sz;
//////            } else if (sz != sonSize) {
//////                flag = false;
//////            }
//////            size += sz;
//////        }
//////        ans += flag ? 1 : 0;
//////        return size;
//////    }
//////
//////    public int countGoodNodes(int[][] edges) {
//////        ans = 0;
//////        // 链式前向星初始化
//////        cnt = 1;
//////        int n = edges.length;
//////        Arrays.fill(head, 0, n + 1, 0);
//////        for (int[] e : edges) {
//////            int u = e[0];
//////            int v = e[1];
//////            add(u, v);
//////            add(v, u);
//////        }
//////        dfs(0, -1);
//////        return ans;
//////    }
//////
//////    public static int MAX_N = 20001;
//////
//////    public static int[] arr = new int[MAX_N];
//////    public static int[] max = new int[MAX_N << 2];
//////    public static int[] change = new int[MAX_N << 2];
//////    public static boolean[] update = new boolean[MAX_N << 2];
//////
//////    public static void up(int i) {
//////        max[i] = Math.max(max[i << 1], max[(i << 1) | 1]);
//////    }
//////
//////    public static void lazy(int i, int v) {
//////        max[i] = v;
//////        change[i] = v;
//////        update[i] = true;
//////    }
//////
//////    public static void down(int i) {
//////        if (update[i]) {
//////            lazy(i << 1, change[i]);
//////            lazy(i << 1 | 1, change[i]);
//////            update[i] = false;
//////        }
//////    }
//////
//////    public static void build(int l, int r, int i) {
//////        if (l < r) {
//////            int mid = (l + r) >> 1;
//////            build(l, mid, i << 1);
//////            build(mid + 1, r, (i << 1) | 1);
//////        }
//////        max[i] = 0;
//////        change[i] = 0;
//////        update[i] = false;
//////    }
//////
//////    public static void update(int jobl, int jobr, int jobv, int l, int r, int i) {
//////        if (jobl <= l && r <= jobr) {
//////            lazy(i, jobv);
//////        } else {
//////            int mid = (l + r) >> 1;
//////            down(i);
//////            if (jobl <= mid) {
//////                update(jobl, jobr, jobv, l, mid, i << 1);
//////            }
//////            if (jobr > mid) {
//////                update(jobl, jobr, jobv, mid + 1, r, (i << 1) | 1);
//////            }
//////            up(i);
//////        }
//////    }
//////
//////    public static int query(int jobl, int jobr, int l, int r, int i) {
//////        if (jobl <= l && r <= jobr) {
//////            return max[i];
//////        } else {
//////            int mid = (l + r) >> 1;
//////            down(i);
//////            int res = Integer.MIN_VALUE;
//////            if (jobl <= mid) {
//////                res = Math.max(res, query(jobl, jobr, l, mid, i << 1));
//////            }
//////            if (jobr > mid) {
//////                res = Math.max(res, query(jobl, jobr, mid + 1, r, (i << 1) | 1));
//////            }
//////            return res;
//////        }
//////    }
//////
//////    public static int collect(int[][] positions) {
//////        int size = 1;
//////        for (int i = 0; i < positions.length; i++) {
//////            arr[size++] = positions[i][0];
//////            arr[size++] = positions[i][0] + positions[i][1] - 1;
//////        }
//////        Arrays.sort(arr, 1, size);
//////        int n = 1;
//////        for (int i = 2; i < size; i++) {
//////            if (arr[i] != arr[n]) {
//////                arr[++n] = arr[i];
//////            }
//////        }
//////        return n;
//////    }
//////
//////    public static int rank(int n, int v) {
//////        int ans = 0;
//////        int l = 1;
//////        int r = n;
//////        while (l <= r) {
//////            int mid = (l + r) >> 1;
//////            if (arr[mid] >= v) {
//////                ans = mid;
//////                r = mid - 1;
//////            } else {
//////                l = mid + 1;
//////            }
//////        }
//////        return ans;
//////    }
//////
//////    public List<Integer> fallingSquares(int[][] positions) {
//////        int n = collect(positions);
//////        build(1, n, 1);
//////        List<Integer> ans = new ArrayList<>();
//////        int max = 0;
//////        for (int[] position : positions) {
//////            int l = rank(n, position[0]);
//////            int r = rank(n, position[0] + position[1] - 1);
//////            int h = query(l, r, 1, n, 1) + position[1];
//////            max = Math.max(h, max);
//////            ans.add(max);
//////            update(l, r, h, 1, n, 1);
//////        }
//////        return ans;
//////    }
//////
//////    public class TreeNode {
//////        int val;
//////        TreeNode left;
//////        TreeNode right;
//////
//////        TreeNode() {
//////        }
//////
//////        TreeNode(int val) {
//////            this.val = val;
//////        }
//////
//////        TreeNode(int val, TreeNode left, TreeNode right) {
//////            this.val = val;
//////            this.left = left;
//////            this.right = right;
//////        }
//////    }
//////
//////
//////
//////    public int findCircleNum(int[][] isConnected) {
//////
//////    }
//////
//////    public static List<Integer> ret = new ArrayList<>();
//////
//////    public List<Integer> inorderTraversal(TreeNode root) {
//////        ret.clear();
//////        solve(root);
//////        return ret;
//////    }
//////
//////    public static void solve(TreeNode root) {
//////        if (root == null) {
//////            return;
//////        }
//////        solve(root.left);
//////        ret.add(root.val);
//////        solve(root.right);
//////    }
//////
//////    class Solution {
//////        public int minFlips(int[][] grid) {
//////            int cnt = 0;
//////            int m = grid.length;
//////            int n = grid[0].length;
//////            int midRow = m / 2, midCol = n / 2;
//////            for (int i = 0; i < midRow; i++) {
//////                for (int j = 0; j < midCol; j++) {
//////                    int sum = grid[i][j] + grid[i][n - 1 - j] + grid[m - 1 - i][j] + grid[m - 1 - i][n - 1 - j];
//////                    cnt += Math.min(sum, 4 - sum);
//////                }
//////            }
//////            if (m % 2 != 0 && n % 2 != 0) {
//////                cnt += grid[midRow][midCol];
//////            }
//////            int pairNum = 0;
//////            int oneNum = 0;
//////            if (m % 2 != 0) {
//////                int i = 0;
//////                int j = n - 1;
//////                while (i < j) {
//////                    if (grid[midRow][i] != grid[midRow][j]) {
//////                        pairNum++;
//////                    } else {
//////                        oneNum += grid[midRow][i] * 2;
//////                    }
//////                    i++;
//////                    j--;
//////                }
//////            }
//////            if (n % 2 != 0) {
//////                int i = 0;
//////                int j = m - 1;
//////                while (i < j) {
//////                    if (grid[i][midCol] != grid[j][midCol]) {
//////                        pairNum++;
//////                    } else {
//////                        oneNum += grid[i][midCol] * 2;
//////                    }
//////                    i++;
//////                    j--;
//////                }
//////            }
//////            if (pairNum == 0 && oneNum % 4 != 0) {
//////                pairNum += 2;
//////            }
//////            cnt += pairNum;
//////            return cnt;
//////        }
//////    }
//////
//////
//////    public int xorOperation(int n, int start) {
//////        int ans = start;
//////        for (int i = 1; i < n; i++) {
//////            ans ^= (start + 2 * i);
//////        }
//////        return ans;
//////    }
//////
//////    public int numIdenticalPairs(int[] nums) {
//////        int cnt = 0;
//////        for (int i = 0; i < nums.length - 1; i++) {
//////            for (int j = i + 1; j < nums.length; j++) {
//////                if (nums[i] == nums[j]) {
//////                    cnt++;
//////                }
//////            }
//////        }
//////        return cnt;
//////    }
//////
//////    public int countGoodTriplets(int[] arr, int a, int b, int c) {
//////        int count = 0;
//////        for (int i = 0; i < arr.length - 2; i++) {
//////            for (int j = i + 1; j < arr.length - 1; j++) {
//////                for (int k = j + 1; k < arr.length; k++) {
//////                    if (Math.abs(arr[i] - arr[j]) <= a && Math.abs(arr[j] - arr[k]) <= b && Math.abs(arr[i] - arr[k]) <= c) {
//////                        count++;
//////                    }
//////                }
//////            }
//////        }
//////        return count;
//////    }
//////
//////    public String toLowerCase(String s) {
//////        char[] charArray = s.toCharArray();
//////        for (int i = 0; i < charArray.length; i++) {
//////            char c = charArray[i];
//////            if (c >= 'A' && c <= 'Z') {
//////                charArray[i] = (char) (c + 32);
//////            }
//////        }
//////        return String.valueOf(charArray);
//////    }
//////
//////    class Solution {
//////        private static final String Target = "aeiou";
//////
//////        public int vowelStrings(String[] words, int left, int right) {
//////            int ans = 0;
//////            for (int i = left; i <= right; i++) {
//////                String s = words[i];
//////                if (Target.indexOf(s.charAt(0)) != -1 &&
//////                        Target.indexOf(s.charAt(s.length() - 1)) != -1) {
//////                    ans++;
//////                }
//////            }
//////            return ans;
//////        }
//////    }
//////
//////    public int[] shuffle(int[] nums, int n) {
//////        int[] res = new int[n * 2];
//////        for (int i = 0; i < n; i++) {
//////            res[i * 2] = nums[i];
//////            res[i * 2 + 1] = nums[i + n];
//////        }
//////        return res;
//////    }
//////
//////    public int smallestEvenMultiple(int n) {
//////        return 2 * n / gcd(n, 2);
//////    }
//////
//////    public static int gcd(int a, int b) {
//////        if (b == 0) return a;
//////        return gcd(b, a % b);
//////    }
//////
//////    public int minFlips(int[][] grid) {
//////        int n = grid.length;
//////        int m = grid[0].length;
//////        int rowNum = 0;
//////        for (int i = 0; i < n; i++) {
//////            int x = 0;
//////            int y = m - 1;
//////            while (x < y) {
//////                if (grid[i][x] != grid[i][y]) rowNum++;
//////                x++;
//////                y--;
//////            }
//////        }
//////        System.out.println("rowNum = " + rowNum);
//////        int colNum = 0;
//////        for (int i = 0; i < m; i++) {
//////            int x = 0;
//////            int y = n - 1;
//////            while (x < y) {
//////                if (grid[x][i] != grid[y][i]) colNum++;
//////                x++;
//////                y--;
//////            }
//////        }
//////        System.out.println("colNum = " + colNum);
//////        return Math.min(rowNum, colNum);
//////    }
//////
//////    public static int MAXN = 10001;
//////
//////    public static Node[] que = new Node[MAXN];
//////
//////    public static int l, r;
//////
//////    public List<List<Integer>> levelOrder(Node root) {
//////        l = r = 0;
//////        if (root != null)
//////            que[r++] = root;
//////        List<List<Integer>> ans = new ArrayList<>();
//////        while (l < r) {
//////            int num = r - l;
//////            List<Integer> cur = new ArrayList<>();
//////            for (int x = 0; x < num; x++) {
//////                Node tmp = que[l++];
//////                cur.add(tmp.val);
//////                for (int i = 0; i < tmp.children.size(); i++) {
//////                    que[r++] = tmp.children.get(i);
//////                }
//////            }
//////            ans.add(cur);
//////        }
//////        return ans;
//////    }
//////
//////    public int maxDepth(Node root) {
//////        if (root == null) return 0;
//////        int maxV = 0;
//////        for (int i = 0; i < root.children.size(); i++) {
//////            maxV = Math.max(maxDepth(root.children.get(i)), maxV);
//////        }
//////        return maxV + 1;
//////    }
//////
//////    public List<Integer> preorder(Node root) {
//////        ans.clear();
//////        solve(root);
//////        return ans;
//////    }
//////
//////    public static void solve(Node root) {
//////        if (root == null) return;
//////        ans.add(root.val);
//////        for (Node child : root.children) {
//////            solve(child);
//////        }
//////    }
//////
//////    public static List<Integer> ans = new ArrayList<>();
//////
//////    class Node {
//////        public int val;
//////        public List<Node> children;
//////
//////        public Node() {
//////        }
//////
//////        public Node(int _val) {
//////            val = _val;
//////        }
//////
//////        public Node(int _val, List<Node> _children) {
//////            val = _val;
//////            children = _children;
//////        }
//////    }
//////
//////    ;
//////
//////    public long[] countKConstraintSubstrings(String str, int k, int[][] queries) {
//////        char[] s = str.toCharArray();
//////        int n = s.length;
//////        int l = 0;
//////        int r = 0;
//////        int[] lLeft = new int[n];
//////        long[] preSumLLeft = new long[n + 1];
//////        int cntOne = 0;
//////        while (r < n) {
//////            if (s[r] == '1')
//////                cntOne++;
//////            r++;
//////            while (cntOne > k && r - l - cntOne > k) {
//////                if (s[l] == '1')
//////                    cntOne--;
//////                l++;
//////            }
//////            lLeft[r - 1] = l;
//////        }
//////        for (int i = 1; i < n + 1; i++) {
//////            preSumLLeft[i] = preSumLLeft[i - 1] + lLeft[i - 1];
//////        }
//////        long[] res = new long[queries.length];
//////        for (int i = 0; i < queries.length; i++) {
//////            int ll = queries[i][0], rr = queries[i][1];
//////            if (lLeft[rr] <= ll) {
//////                res[i] = (long) (rr - ll + 1 + 1) * (rr - ll + 1) / 2;
//////            } else {
//////                l = ll;
//////                r = rr;
//////                while (l <= r) {
//////                    int m = (l + r) >> 1;
//////                    if (lLeft[m] >= ll)
//////                        r = m - 1;
//////                    else
//////                        l = m + 1;
//////                }
//////                int index = r;
//////                res[i] += (long) (index - ll + 1 + 1) * (index - ll + 1) / 2;
//////                res[i] += (long) (index + 1 + rr) * (rr - index) / 2 - (preSumLLeft[rr + 1] - preSumLLeft[index + 1])
//////                        + rr - (index + 1) + 1;
//////            }
//////        }
//////        return res;
//////    }
////////    public static int MAX_V = 100001;
////////
////////    public static int MAX_N = 20001;
////////
////////    public static int[] factors = new int[MAX_V];
////////
////////    public static int[] father = new int[MAX_N];
////////
////////    public static int[] size = new int[MAX_N];
////////
////////    public static int n;
////////
////////    public int countKConstraintSubstrings(String s, int K) {
////////        int n = s.length();
////////        int ans = 0;
////////        for (int i = 0; i < n; i++) {
////////            int[] cnt = new int[2];
////////            for (int j = i; j < n; j++) {
////////                cnt[s.charAt(j) - '0']++;
////////                if (cnt[0] <= K || cnt[1] <= K) ans++;
////////            }
////////        }
////////        return ans;
////////    }
////////
////////
////////
////////    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
////////        PriorityQueue<Integer> pq = new PriorityQueue<>();
////////        for (int i = 0; i < input.length; i++) {
////////            pq.add(input[i]);
////////        }
////////        ArrayList<Integer> list = new ArrayList<>();
////////        while (k-- > 0) {
////////            list.add(pq.poll());
////////        }
////////        return list;
////////    }
////////
////////    public int MoreThanHalfNum_Solution(int[] numbers) {
////////        HashMap<Integer, Integer> map = new HashMap<>();
////////        for (int i = 0; i < numbers.length; i++) {
////////            map.put(numbers[i], map.getOrDefault(numbers[i], 0) + 1);
////////        }
////////        int ans = 0;
////////        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
////////            if (entry.getValue() > numbers.length / 2) {
////////                ans = entry.getKey();
////////                break;
////////            }
////////        }
////////        return ans;
////////    }
////////
////////    class NeighborSum {
////////        public int[][] grid;
////////        public Map<Integer, int[]> map = new HashMap<>();
////////        public int[] dir1 = {-1, 0, 1, 0, -1};
////////
////////        public int[] dir2 = {-1, 1, 1, -1, -1};
////////
////////        public NeighborSum(int[][] g) {
////////            this.grid = g;
////////            int m = grid.length, n = grid[0].length;
////////            for (int i = 0; i < m; ++i) {
////////                for (int j = 0; j < n; ++j) {
////////                    map.put(grid[i][j], new int[]{i, j});
////////                }
////////            }
////////        }
////////
////////        public int adjacentSum(int value) {
////////            int[] p = map.get(value);
////////            int s = 0;
////////            for (int q = 0, x, y; q < 4; ++q) {
////////                x = p[0] + dir1[q];
////////                y = p[1] + dir1[q + 1];
////////                if (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length) {
////////                    s += grid[x][y];
////////                }
////////            }
////////            return s;
////////        }
////////
////////        public int diagonalSum(int value) {
////////            int[] p = map.get(value);
////////            int s = 0;
////////            for (int q = 0, x, y; q < 4; ++q) {
////////                x = p[0] + dir2[q];
////////                y = p[1] + dir2[q + 1];
////////                if (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length) {
////////                    s += grid[x][y];
////////                }
////////            }
////////            return s;
////////        }
////////    }
////////
////////    /**
////////     * Your NeighborSum object will be instantiated and called as such:
////////     * NeighborSum obj = new NeighborSum(grid);
////////     * int param_1 = obj.adjacentSum(value);
////////     * int param_2 = obj.diagonalSum(value);
////////     */
////////
////////
////////    public int countPrimes1(int n) {
////////        boolean[] visited = new boolean[n + 1];
////////        for (int i = 2; i * i <= n; i++) {
////////            if (!visited[i]) {
////////                for (int j = i * i; j <= n; j += i) {
////////                    visited[j] = true;
////////                }
////////            }
////////        }
////////        int cnt = 0;
////////        for (int i = 2; i <= n; i++) {
////////            if (!visited[i]) {
////////                cnt++;
////////            }
////////        }
////////        return cnt;
////////    }
////////
////////    public int countPrimes(int n) {
////////        n -= 1;
////////        boolean[] visited = new boolean[n + 1];
////////        int cnt = (n + 1) / 2;
////////        for (int i = 3; i * i <= n; i += 2) {
////////            if (!visited[i]) {
////////                for (int j = i * i; j <= n; j += i * 2) {
////////                    if (!visited[j]) {
////////                        cnt--;
////////                        visited[j] = true;
////////                    }
////////                }
////////            }
////////        }
////////        return cnt;
////////    }
////////
////////    public int countPrimes2(int n) {
////////        n -= 1;
////////        boolean[] visited = new boolean[n + 1];
////////        int[] primes = new int[n / 2 + 1];
////////        int cnt = 0;
////////        for (int i = 2; i * i <= n; i++) {
////////            if (!visited[i]) {
////////                primes[cnt++] = i;
////////            }
////////            for (int j = 0; j < cnt; j++) {
////////                if (i * primes[j] > n) {
////////                    break;
////////                }
////////                visited[i * primes[j]] = true;
////////                if (i % primes[j] == 0) {
////////                    break;
////////                }
////////            }
////////        }
////////        return cnt;
////////    }
////////
////////    public static void build() {
////////        for (int i = 0; i <= n; i++) {
////////            father[i] = i;
////////            size[i] = 1;
////////        }
////////        Arrays.fill(factors, -1);
////////    }
////////
////////    public static int find(int x) {
////////        if (x != father[x]) {
////////            father[x] = find(father[x]);
////////        }
////////        return father[x];
////////    }
////////
////////    public static void union(int x, int y) {
////////        int fx = find(x);
////////        int fy = find(y);
////////        if (fx != fy) {
////////            father[fy] = fx;
////////            size[fx] += size[fy];
////////        }
////////    }
////////
////////    public static int maxSize() {
////////        int ans = 0;
////////        for (int i = 0; i < n; i++) {
////////            ans = Math.max(size[find(i)], ans);
////////        }
////////        return ans;
////////    }
////////
////////
////////    public int largestComponentSize(int[] nums) {
////////        n = nums.length;
////////        build();
////////        for (int i = 0; i < n; i++) {
////////            int x = nums[i];
////////            for (int j = 2; j * j <= x; j++) {
////////                if (x % j == 0) {
////////                    if (factors[j] == -1) {
////////                        factors[j] = i;
////////                    } else {
////////                        union(i, factors[j]);
////////                    }
////////                }
////////                while (x % j == 0) {
////////                    x /= j;
////////                }
////////            }
////////            if (x > 1) {
////////                if (factors[x] == -1) {
////////                    factors[x] = i;
////////                } else {
////////                    union(i, factors[x]);
////////                }
////////            }
////////        }
////////        return maxSize();
////////    }
//////////    public class TreeNode {
//////////
//////////        int val;
//////////        TreeNode left;
//////////        TreeNode right;
//////////
//////////        TreeNode() {
//////////        }
//////////
//////////        TreeNode(int val) {
//////////            this.val = val;
//////////        }
//////////
//////////        TreeNode(int val, TreeNode left, TreeNode right) {
//////////            this.val = val;
//////////            this.left = left;
//////////            this.right = right;
//////////        }
//////////
//////////    }
//////////
//////////    public static int MAX_N = 1001;
//////////    public static int[] dfn = new int[MAX_N];
//////////
//////////    public static int[] size = new int[MAX_N];
//////////
//////////    public static int[] xor = new int[MAX_N];
//////////    public static int dfnCnt;
//////////
//////////    public static int MOD = 1000000007;
//////////
//////////    public static class Project {
//////////        public int p;
//////////        public int c;
//////////
//////////        public Project(int profit, int cost) {
//////////            p = profit;
//////////            c = cost;
//////////        }
//////////    }
//////////
//////////    public static class Node {
//////////        public int v;
//////////        public int i;
//////////        public int j;
//////////
//////////        public Node(int a, int b, int c) {
//////////            v = a;
//////////            i = b;
//////////            j = c;
//////////        }
//////////    }
//////////
//////////    public int minimumDeviation(int[] nums) {
//////////        TreeSet<Integer> set = new TreeSet<>();
//////////        for (int i = 0; i < nums.length; i++) {
//////////            if (nums[i] % 2 == 0) {
//////////                set.add(nums[i]);
//////////            } else {
//////////                set.add(nums[i] * 2);
//////////            }
//////////        }
//////////        int ans = set.last() - set.first();
//////////        while (ans > 0 && set.last() % 2 == 0) {
//////////            int val = set.last();
//////////            set.remove(val);
//////////            set.add(val / 2);
//////////            ans = Math.min(ans, set.last() - set.first());
//////////        }
//////////        return ans;
//////////    }
//////////
//////////    // 快速幂，求余数
//////////    // 求x的n次方，最终得到的结果 % mod
//////////    public static long power(long x, int n, int mod) {
//////////        long ans = 1;
//////////        while (n > 0) {
//////////            if ((n & 1) == 1) {
//////////                ans = (ans * x) % mod;
//////////            }
//////////            x = (x * x) % mod;
//////////            n >>= 1;
//////////        }
//////////        return ans;
//////////    }
//////////
//////////    public static int[] smallestRange(List<List<Integer>> nums) {
//////////        int k = nums.size();
//////////        TreeSet<int[]> set = new TreeSet<>((a, b) -> a[0] != b[0] ? (a[0] - b[0]) : (a[1] - b[1]));
//////////        for (int i = 0; i < k; i++) {
//////////            set.add(new int[]{nums.get(i).get(0), i, 0});
//////////        }
//////////        int r = Integer.MAX_VALUE;
//////////        int a = 0;
//////////        int b = 0;
//////////        int[] max, min;
//////////        while (set.size() == k) {
//////////            max = set.last();
//////////            min = set.pollFirst();
//////////            if (max[0] - min[0] < r) {
//////////                r = max[0] - min[0];
//////////                a = min[0];
//////////                b = max[0];
//////////            }
//////////            if (min[2] + 1 < nums.get(min[1]).size()) {
//////////                set.add(new int[]{nums.get(min[1]).get(min[2] + 1), min[1], min[2] + 1});
//////////            }
//////////        }
//////////        return new int[]{a, b};
//////////    }
//////////
//////////    public static int findMaximizedCapital(int k, int w, int[] profit, int[] cost) {
//////////        int n = profit.length;
//////////        PriorityQueue<int[]> heap1 = new PriorityQueue<>((a, b) -> a[1] - b[1]);
//////////        PriorityQueue<int[]> heap2 = new PriorityQueue<>((a, b) -> b[0] - a[0]);
//////////        for (int i = 0; i < n; i++) {
//////////            heap1.add(new int[]{profit[i], cost[i]});
//////////        }
//////////        while (k > 0) {
//////////            while (!heap1.isEmpty() && heap1.peek()[1] <= w) {
//////////                heap2.add(heap1.poll());
//////////            }
//////////            if (heap2.isEmpty()) {
//////////                break;
//////////            }
//////////            w += heap2.poll()[0];
//////////            k--;
//////////        }
//////////        return w;
//////////    }
//////////
//////////    public static long quickPow(long x, int n, int mod) {
//////////        long ans = 1;
//////////        while (n > 0) {
//////////            if ((n & 1) == 1) {
//////////                ans = (ans * x) % mod;
//////////            }
//////////            x = (x * x) % mod;
//////////            n >>= 1;
//////////        }
//////////        return ans;
//////////    }
//////////
//////////    public static int cuttingBamboo(int n) {
//////////        if (n == 2) {
//////////            return 1;
//////////        }
//////////        if (n == 3) {
//////////            return 2;
//////////        }
//////////        int tail = n % 3 == 0 ? 1 : (n % 3 == 1 ? 4 : 2);
//////////        int power = (tail == 1 ? n : (n - tail)) / 3;
//////////        return (int) (quickPow(3, power, MOD) * tail % MOD);
//////////    }
//////////
//////////    public int scheduleCourse(int[][] courses) {
//////////        Arrays.sort(courses, (a, b) -> a[1] - b[1]);
//////////        PriorityQueue<Integer> heap = new PriorityQueue<>((a, b) -> (b - a));
//////////        int time = 0;
//////////        for (int[] c : courses) {
//////////            if (time + c[0] <= c[1]) {
//////////                heap.add(c[0]);
//////////                time += c[0];
//////////            } else {
//////////                if (!heap.isEmpty() && heap.peek() > c[0]) {
//////////                    time += c[0] - heap.poll();
//////////                    heap.add(c[0]);
//////////                }
//////////            }
//////////        }
//////////        return heap.size();
//////////    }
//////////
//////////    public int twoCitySchedCost(int[][] costs) {
//////////        int n = costs.length;
//////////        int[] arr = new int[n];
//////////        int sum = 0;
//////////        for (int i = 0; i < n; i++) {
//////////            arr[i] = costs[i][0] - costs[i][1];
//////////            sum += costs[i][0];
//////////        }
//////////        Arrays.sort(arr);
//////////        int m = n / 2;
//////////        for (int i = 0; i < m; i++) {
//////////            sum += arr[i];
//////////        }
//////////        return sum;
//////////    }
//////////
//////////
//////////    public String largestNumber(int[] nums) {
//////////        String[] strs = new String[nums.length];
//////////        for (int i = 0; i < nums.length; i++) {
//////////            strs[i] = String.valueOf(nums[i]);
//////////        }
//////////        Arrays.sort(strs, (a, b) -> {
//////////            return (a + b).compareTo((b + a));
//////////        });
//////////        StringBuilder path = new StringBuilder();
//////////        for (int i = 0; i < strs.length; i++) {
//////////            path.append(strs[i]);
//////////        }
//////////        return path.toString();
//////////    }
//////////
//////////    public int[] resultsArray(int[] nums, int k) {
//////////        int n = nums.length;
//////////        int[] ans = new int[n - k + 1];
//////////        Arrays.fill(ans, -1);
//////////        for (int i = 0, cnt = 0; i < n; i++) {
//////////            cnt = i == 0 || nums[i] == nums[i - 1] + 1 ? cnt + 1 : 1;
//////////            if (cnt >= k) {
//////////                ans[i - k + 1] = nums[i];
//////////            }
//////////        }
//////////        return ans;
//////////    }
//////////
//////////    public int maxProfit(int[] prices) {
//////////        int ans = 0;
//////////        for (int i = 1; i < prices.length; i++) {
//////////            ans += Math.max(0, prices[i] - prices[i - 1]);
//////////        }
//////////        return ans;
//////////    }
//////////
//////////    public int numberWays(List<List<Integer>> arr) {
//////////        int m = 0;
//////////        for (List<Integer> hat : arr) {
//////////            for (Integer x : hat) {
//////////                m = Math.max(m, x);
//////////            }
//////////        }
//////////        int n = arr.size();
//////////        int[] hats = new int[m + 1];
//////////        for (int pi = 0; pi < n; pi++) {
//////////            for (int x : arr.get(pi)) {
//////////                hats[x] |= (1 << pi);
//////////            }
//////////        }
//////////        int[][] dp = new int[m + 1][1 << n];
//////////        for (int i = 0; i <= m; i++) {
//////////            Arrays.fill(dp[i], -1);
//////////        }
//////////        return f(hats, m, n, 1, 0, dp);
//////////    }
//////////
//////////    public static int f(int[] hats, int m, int n, int i, int s, int[][] dp) {
//////////        if (s == (1 << n) - 1) {
//////////            return 1;
//////////        }
//////////        if (i == m + 1) {
//////////            return 0;
//////////        }
//////////        if (dp[i][s] != -1) {
//////////            return dp[i][s];
//////////        }
//////////        int ans = f(hats, m, n, i + 1, s, dp);
//////////        int cur = hats[i];
//////////        int rightOne = 0;
//////////        while (cur != 0) {
//////////            rightOne = cur & (-cur);
//////////            if ((rightOne & s) == 0) {
//////////                ans = (ans + f(hats, m, n, i + 1, s | cur, dp));
//////////            }
//////////            cur -= rightOne;
//////////        }
//////////        dp[i][s] = ans;
//////////        return ans;
//////////    }
//////////
//////////    public boolean canIWin(int n, int m) {
//////////        if (m == 0) return true;
//////////        if (n * (n + 1) / 2 < m) return false;
//////////        int[] dp = new int[1 << (n + 1)];
//////////        return f(n, (1 << (n + 1)) - 1, m, dp);
//////////    }
//////////
//////////    public boolean makesquare(int[] matchsticks) {
//////////        int n = matchsticks.length;
//////////        int sum = 0;
//////////        for (int matchstick : matchsticks) {
//////////            sum += matchstick;
//////////        }
//////////        if (sum % 4 != 0) return false;
//////////        int[] dp = new int[1 << n];
//////////        return f(matchsticks, (1 << n) - 1, sum / 4, 0, 4, dp);
//////////    }
//////////
//////////    private boolean f(int[] nums, int status, int limit, int cur, int rest, int[] dp) {
//////////        if (rest == 0) {
//////////            return status == 0;
//////////        }
//////////        if (dp[status] != 0) return dp[status] == 1;
//////////        boolean ans = false;
//////////        for (int i = 0; i < nums.length; i++) {
//////////            if ((((1 << i) & status) != 0) && nums[i] + cur <= limit) {
//////////                if (nums[i] + cur == limit) {
//////////                    ans = f(nums, status ^ (1 << i), limit, 0, rest - 1, dp);
//////////                } else {
//////////                    ans = f(nums, status ^ (1 << i), limit, cur + nums[i], rest, dp);
//////////                }
//////////                if (ans) {
//////////                    break;
//////////                }
//////////            }
//////////        }
//////////        dp[status] = ans ? 1 : -1;
//////////        return ans;
//////////    }
//////////
//////////    public boolean f(int n, int status, int rest, int[] dp) {
//////////        if (rest <= n) {
//////////            return false;
//////////        }
//////////        if (dp[status] != 0) {
//////////            return dp[status] == 1;
//////////        }
//////////        boolean ans = false;
//////////        for (int i = 1; i <= n; i++) {
//////////            if (((1 << i) & status) != 0 && f(n, status ^ (1 << i), rest - i, dp)) {
//////////                ans = true;
//////////                break;
//////////            }
//////////        }
//////////        dp[status] = ans ? 1 : -1;
//////////        return ans;
//////////    }
//////////
//////////
//////////    public int minimumScore(int[] nums, int[][] edges) {
//////////        int n = nums.length;
//////////        ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
//////////        for (int i = 0; i < n; i++) {
//////////            graph.add(new ArrayList<>());
//////////        }
//////////        for (int[] edge : edges) {
//////////            graph.get(edge[0]).add(edge[1]);
//////////            graph.get(edge[1]).add(edge[0]);
//////////        }
//////////        Arrays.fill(dfn, 0, n, 0);
//////////        dfnCnt = 0;
//////////        f(nums, graph, 0);
//////////        int m = edges.length;
//////////        int ans = Integer.MAX_VALUE;
//////////        for (int i = 0, a, b, pre, pos, sum1, sum2, sum3; i < m; i++) {
//////////            a = Math.max(dfn[edges[i][0]], dfn[edges[i][1]]);
//////////            for (int j = i + 1; j < m; j++) {
//////////                b = Math.max(dfn[edges[j][0]], dfn[edges[j][1]]);
//////////                if (a < b) {
//////////                    pre = a;
//////////                    pos = b;
//////////                } else {
//////////                    pre = b;
//////////                    pos = a;
//////////                }
//////////                sum1 = xor[pos];
//////////                if (pos < pre + size[pre]) {
//////////                    sum2 = xor[pre] ^ xor[pos];
//////////                    sum3 = xor[1] ^ xor[pre];
//////////                } else {
//////////                    sum2 = xor[pre];
//////////                    sum3 = xor[1] ^ sum1 ^ sum2;
//////////                }
//////////                ans = Math.min(ans, Math.max(Math.max(sum1, sum2), sum3) - Math.min(Math.min(sum1, sum2), sum3));
//////////            }
//////////        }
//////////        return ans;
//////////    }
//////////
//////////    public static void f(int[] nums, ArrayList<ArrayList<Integer>> graph, int u) {
//////////        int id = ++dfnCnt;
//////////        dfn[u] = id;
//////////        xor[id] = nums[u];
//////////        size[id] = 1;
//////////        for (int v : graph.get(u)) {
//////////            if (dfn[v] == 0) {
//////////                f(nums, graph, v);
//////////                xor[id] ^= xor[dfn[v]];
//////////                size[id] += size[dfn[v]];
//////////            }
//////////        }
//////////    }
//////////
//////////
////////////
////////////    public class TreeNode {
////////////
////////////        int val;
////////////        TreeNode left;
////////////        TreeNode right;
////////////
////////////        TreeNode() {
////////////        }
////////////
////////////        TreeNode(int val) {
////////////            this.val = val;
////////////        }
////////////
////////////        TreeNode(int val, TreeNode left, TreeNode right) {
////////////            this.val = val;
////////////            this.left = left;
////////////            this.right = right;
////////////        }
////////////
////////////    }
////////////
////////////
////////////    public static int ans;
////////////
////////////    public static int MAX_N = 100005;
////////////    public static int[] dfn = new int[MAX_N];
////////////
////////////    public static int[] size = new int[MAX_N];
////////////
////////////    public static int dfnCnt;
////////////
////////////    public static int[] deep = new int[MAX_N];
////////////    public static int[] maxl = new int[MAX_N];
////////////    public static int[] maxr = new int[MAX_N];
////////////
////////////
////////////    public int[] treeQueries(TreeNode root, int[] queries) {
////////////        dfnCnt = 0;
////////////        f(root, 0);
////////////        for (int i = 1; i <= dfnCnt; i++) {
////////////            maxl[i] = Math.max(maxl[i - 1], deep[i]);
////////////        }
////////////        maxr[dfnCnt + 1] = 0;
////////////        for (int i = dfnCnt; i >= 1; i--) {
////////////            maxr[i] = Math.max(maxr[i + 1], deep[i]);
////////////        }
////////////        int n = queries.length;
////////////        int[] ans = new int[n];
////////////        for (int i = 0; i < n; i++) {
////////////            int x = queries[i];
////////////            int leftMax = maxl[dfn[x] - 1];
////////////            int rightMax = maxr[dfn[x] + size[dfn[x]]];
////////////            ans[i] = Math.max(leftMax, rightMax);
////////////        }
////////////        return ans;
////////////    }
////////////
////////////    public static void f(TreeNode root, int k) {
////////////        int i = ++dfnCnt;
////////////        dfn[root.val] = i;
////////////        deep[i] = k;
////////////        size[i] = 1;
////////////        if (root.left != null) {
////////////            f(root.left, k + 1);
////////////            size[i] += size[dfn[root.left.val]];
////////////        }
////////////        if (root.right != null) {
////////////            f(root.right, k + 1);
////////////            size[i] += size[dfn[root.right.val]];
////////////        }
////////////    }
////////////
////////////    public static int longestPath(int[] parent, String str) {
////////////        int n = parent.length;
////////////        char[] s = str.toCharArray();
////////////        ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
////////////        for (int i = 0; i < n; i++) {
////////////            graph.add(new ArrayList<>());
////////////        }
////////////        for (int i = 1; i < n; i++) {
////////////            graph.get(parent[i]).add(i);
////////////        }
////////////        return f(s, graph, 0).maxPath;
////////////    }
////////////
////////////    public static class Info {
////////////        public int maxPathFromHead;
////////////        public int maxPath;
////////////
////////////        public Info(int a, int b) {
////////////            maxPathFromHead = a;
////////////            maxPath = b;
////////////        }
////////////    }
////////////
////////////    public static Info f(char[] s, ArrayList<ArrayList<Integer>> graph, int u) {
////////////        if (graph.get(u).isEmpty()) {
////////////            // u节点是叶
////////////            return new Info(1, 1);
////////////        }
////////////        int max1 = 0; // 下方最长链
////////////        int max2 = 0; // 下方次长链
////////////        int maxPath = 1;
////////////        for (int v : graph.get(u)) {
////////////            Info nextInfo = f(s, graph, v);
////////////            maxPath = Math.max(maxPath, nextInfo.maxPath);
////////////            if (s[u] != s[v]) {
////////////                if (nextInfo.maxPathFromHead > max1) {
////////////                    max2 = max1;
////////////                    max1 = nextInfo.maxPathFromHead;
////////////                } else if (nextInfo.maxPathFromHead > max2) {
////////////                    max2 = nextInfo.maxPathFromHead;
////////////                }
////////////            }
////////////        }
////////////        int maxPathFromHead = max1 + 1;
////////////        maxPath = Math.max(maxPath, max1 + max2 + 1);
////////////        return new Info(maxPathFromHead, maxPath);
////////////    }
////////////
////////////    public long minimumFuelCost(int[][] roads, int seats) {
////////////        int n = roads.length + 1;
////////////        ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
////////////        for (int i = 0; i < n; i++) {
////////////            graph.add(new ArrayList<>());
////////////        }
////////////        for (int[] road : roads) {
////////////            graph.get(road[0]).add(road[1]);
////////////            graph.get(road[1]).add(road[0]);
////////////        }
////////////        int[] size = new int[n];
////////////        long[] cost = new long[n];
////////////        f(graph, seats, 0, -1, size, cost);
////////////        return cost[0];
////////////    }
////////////
////////////    private void f(ArrayList<ArrayList<Integer>> graph, int seats, int u, int p, int[] size, long[] cost) {
////////////        size[u] = 1;
////////////        for (int next : graph.get(u)) {
////////////            if (next != p) {
////////////                f(graph, seats, next, u, size, cost);
////////////                size[u] += size[next];
////////////                cost[u] += cost[next];
////////////                cost[u] += (seats + size[next] - 1) / seats;
////////////            }
////////////        }
////////////    }
////////////
////////////    public int minCameraCover(TreeNode root) {
////////////        ans = 0;
////////////        if (f1(root) == 0) {
////////////            ans++;
////////////        }
////////////        return ans;
////////////    }
////////////
////////////    public int f1(TreeNode root) {
////////////        if (root == null) {
////////////            return 1;
////////////        }
////////////        int left = f1(root.left);
////////////        int right = f1(root.right);
////////////        if (left == 0 || right == 0) {
////////////            ans++;
////////////            return 2;
////////////        }
////////////        if (left == 1 && right == 1) {
////////////            return 0;
////////////        }
////////////        return 1;
////////////    }
////////////
////////////
//////////////    public int diameterOfBinaryTree(TreeNode root) {
//////////////        return f(root).move;
//////////////    }
////////////
////////////
//////////////    public static class Info {
//////////////        public int cnt;
//////////////
//////////////        public int sum;
//////////////
//////////////        public int move;
//////////////
//////////////        public Info(int cnt, int sum, int move) {
//////////////            this.cnt = cnt;
//////////////            this.sum = sum;
//////////////            this.move = move;
//////////////        }
//////////////    }
////////////
//////////////    public static Info f(TreeNode root) {
//////////////        if (root == null)
//////////////            return new Info(0, 0, 0);
//////////////        Info infoL = f(root.left);
//////////////        Info infoR = f(root.right);
//////////////        int cnt = infoL.cnt + infoR.cnt + 1;
//////////////        int sum = infoL.sum + infoR.sum + root.val;
//////////////        int move = infoL.move + infoR.move + Math.abs(infoL.cnt - infoL.sum) + Math.abs(infoR.cnt - infoR.sum);
//////////////        return new Info(cnt, sum, move);
//////////////    }
////////////
////////////
////////////    public static int removeBoxes(int[] boxes) {
////////////        int n = boxes.length;
////////////        int[][][] dp = new int[n][n][n];
////////////        return f(boxes, 0, n - 1, 0, dp);
////////////    }
////////////
////////////    public static int f(int[] boxes, int l, int r, int k) {
////////////        if (l > r) {
////////////            return 0;
////////////        }
////////////        int s = l;
////////////        while (s + 1 <= r && boxes[l] == boxes[s + 1]) {
////////////            s++;
////////////        }
////////////        int cnt = k + s - l + 1;
////////////        int ans = cnt * cnt + f(boxes, s + 1, r, 0);
////////////        for (int m = s + 2; m <= r; m++) {
////////////            if (boxes[l] == boxes[m] && boxes[m - 1] != boxes[m]) {
////////////                ans = Math.max(ans, f(boxes, s + 1, m - 1, 0) + f(boxes, m, r, cnt));
////////////            }
////////////        }
////////////        return ans;
////////////    }
////////////
////////////    public static int f(int[] boxes, int l, int r, int k, int[][][] dp) {
////////////        if (l > r) {
////////////            return 0;
////////////        }
////////////        if (dp[l][r][k] > 0) {
////////////            return dp[l][r][k];
////////////        }
////////////        int s = l;
////////////        while (s + 1 <= r && boxes[l] == boxes[s + 1]) {
////////////            s++;
////////////        }
////////////        int cnt = k + s - l + 1;
////////////        int ans = cnt * cnt + f(boxes, s + 1, r, 0, dp);
////////////        for (int m = s + 2; m <= r; m++) {
////////////            if (boxes[l] == boxes[m] && boxes[m - 1] != boxes[m]) {
////////////                ans = Math.max(ans, f(boxes, s + 1, m - 1, 0, dp) + f(boxes, m, r, cnt, dp));
////////////            }
////////////        }
////////////        dp[l][r][k] = ans;
////////////        return ans;
////////////    }
////////////
////////////    public int countEval(String str, int result) {
////////////        int n = str.length();
////////////        char[] s = str.toCharArray();
////////////        int[][][] dp = new int[n][n][];
////////////        int[] ret = f(s, 0, n - 1, dp);
////////////        return ret[result];
////////////    }
////////////
////////////    private int[] f(char[] s, int l, int r, int[][][] dp) {
////////////        if (dp[l][r] != null) return dp[l][r];
////////////        int f = 0;
////////////        int t = 0;
////////////        if (l == r) {
////////////            f = s[l] == '0' ? 1 : 0;
////////////            t = s[r] == '1' ? 1 : 0;
////////////        } else {
////////////            int[] tmp;
////////////            for (int k = l + 1, a, b, c, d; k < r; k += 2) {
////////////                tmp = f(s, l, k - 1, dp);
////////////                a = tmp[0];
////////////                b = tmp[1];
////////////                tmp = f(s, k + 1, r, dp);
////////////                c = tmp[0];
////////////                d = tmp[1];
////////////                if (s[k] == '&') {
////////////                    f += a * c + a * d + b * c;
////////////                    t += b * d;
////////////                } else if (s[k] == '|') {
////////////                    f += a * c;
////////////                    t += a * d + b * c + b * d;
////////////                } else {
////////////                    f += a * c + b * d;
////////////                    t += a * d + b * c;
////////////                }
////////////            }
////////////        }
////////////        int[] ans = new int[]{f, t};
////////////        dp[l][r] = ans;
////////////        return ans;
////////////    }
////////////
////////////    public static int[] father = new int[MAX_N];
////////////
////////////
////////////    public static int count;
////////////
////////////    public static void build(int n) {
////////////        for (int i = 1; i <= n; i++) father[i] = i;
////////////        count = n;
////////////    }
////////////
////////////    public static int find(int x) {
////////////        if (x != father[x]) {
////////////            father[x] = find(father[x]);
////////////        }
////////////        return father[x];
////////////    }
////////////
////////////    public static void union(int x, int y) {
////////////        int fx = find(x);
////////////        int fy = find(y);
////////////        if (fx != fy) {
////////////            father[fy] = fx;
////////////            count--;
////////////        }
////////////    }
////////////
////////////    public static boolean isSameSet(int x, int y) {
////////////        return find(x) == find(y);
////////////    }
////////////
////////////    public int makeConnected(int n, int[][] connections) {
////////////        build(n - 1);
////////////        int ans = 0;
////////////        for (int[] connection : connections) {
////////////            int from = connection[0];
////////////            int to = connection[1];
////////////            if (isSameSet(from, to)) {
////////////                ans++;
////////////            } else {
////////////                union(from, to);
////////////            }
////////////        }
////////////        return count - ans >= 0 ? count - ans : -1;
////////////    }
////////////
////////////    public boolean judgeSquareSum(int c) {
////////////        for (int left = 0; left * left <= c / 2; left++) {
////////////            int right = (int) Math.sqrt(c - left * left);
////////////            if (left * left + right * right == c) {
////////////                return true;
////////////            }
////////////        }
////////////        return false;
////////////    }
////////////
////////////
////////////    public boolean judgeSquareSum2(int c) {
////////////        long left = 1;
////////////        long right = (long) Math.sqrt(c);
////////////        while (left <= right) {
////////////            if (left * left + right * right == c) return true;
////////////            else if (left * left + right * right > c) right--;
////////////            else left++;
////////////        }
////////////        return false;
////////////    }
////////////
////////////    public int maxCoins(int[] nums) {
////////////        int n = nums.length;
////////////        int[] arr = new int[n + 2];
////////////        arr[0] = 1;
////////////        arr[n + 1] = 1;
////////////        for (int i = 0; i < n; i++) {
////////////            arr[i + 1] = nums[i];
////////////        }
////////////        int[][] dp = new int[n + 2][n + 2];
////////////        for (int i = 1; i <= n; i++) {
////////////            dp[i][i] = arr[i - 1] * arr[i] * arr[i + 1];
////////////        }
////////////        for (int l = n, ans; l >= 1; l--) {
////////////            for (int r = l + 1; r <= n; r++) {
////////////                ans = Math.max(arr[l - 1] * arr[l] * arr[r + 1] + dp[l + 1][r],
////////////                        arr[l - 1] * arr[r] * arr[r + 1] + dp[l][r - 1]);
////////////                for (int k = l + 1; k < r; k++) {
////////////                    ans = Math.max(ans, arr[l - 1] * arr[k] * arr[r + 1] + dp[l][k - 1] + dp[k + 1][r]);
////////////                }
////////////                dp[l][r] = ans;
////////////            }
////////////        }
////////////        return dp[1][n];
////////////    }
////////////
////////////    public int f3(int[] arr, int l, int r, int[][] dp) {
////////////        if (dp[l][r] != -1) return dp[l][r];
////////////        if (l > r) {
////////////            return 0;
////////////        }
////////////        int ans = 0;
////////////        if (l == r) {
////////////            return arr[l - 1] * arr[l] * arr[r + 1];
////////////        } else {
////////////            ans = Math.max(
////////////                    arr[l - 1] * arr[l] * arr[r + 1] + f(arr, l + 1, r, dp),
////////////                    arr[l - 1] * arr[r] * arr[r + 1] + f(arr, l, r - 1, dp));
////////////            for (int k = l + 1; k < r; k++) {
////////////                ans = Math.max(ans, arr[l - 1] * arr[k] * arr[r + 1] + f(arr, l, k - 1, dp) + f(arr, k + 1, r, dp));
////////////            }
////////////        }
////////////        dp[l][r] = ans;
////////////        return ans;
////////////    }
////////////
////////////    public int minCost(int n, int[] cuts) {
////////////        int m = cuts.length;
////////////        Arrays.sort(cuts);
////////////        int[] arr = new int[m + 2];
////////////        arr[0] = 0;
////////////        for (int i = 1; i <= m; i++) {
////////////            arr[i] = cuts[i - 1];
////////////        }
////////////        arr[m + 1] = n;
////////////        int[][] dp = new int[m + 2][m + 2];
////////////        for (int i = 0; i <= m; i++) {
////////////            dp[i][i] = arr[i + 1] - arr[i - 1];
////////////        }
////////////        for (int l = m - 1, next; l >= 1; l--) {
////////////            for (int r = l + 1; r <= m; r++) {
////////////                next = Integer.MAX_VALUE;
////////////                for (int k = l; k <= r; k++) {
////////////                    next = Math.min(next, dp[l][k - 1] + dp[k + 1][r]);
////////////                }
////////////                dp[l][r] = arr[r + 1] - arr[l - 1] + next;
////////////            }
////////////        }
////////////        return dp[1][m];
////////////    }
////////////
////////////    private int f2(int[] arr, int l, int r, int[][] dp) {
////////////        if (l > r) return 0;
////////////        if (l == r) {
////////////            return arr[r + 1] - arr[l - 1];
////////////        }
////////////        if (dp[l][r] != -1) return dp[l][r];
////////////        int ans = Integer.MAX_VALUE;
////////////        for (int k = l; k <= r; k++) {
////////////            ans = Math.min(ans, f2(arr, l, k - 1, dp) + f2(arr, k + 1, r, dp));
////////////        }
////////////        ans += arr[r + 1] - arr[l - 1];
////////////        dp[l][r] = ans;
////////////        return ans;
////////////    }
////////////
////////////    public int minScoreTriangulation(int[] values) {
////////////        int n = values.length;
////////////        int[][] dp = new int[n][n];
////////////        for (int i = 0; i < n; i++) {
////////////            Arrays.fill(dp[i], Integer.MAX_VALUE);
////////////        }
////////////        for (int i = 0; i < n - 1; i++) {
////////////            dp[i][i + 1] = 0;
////////////        }
////////////        for (int i = n - 3; i >= 0; i--) {
////////////            for (int j = i + 2; j < n; j++) {
////////////                for (int k = i + 1; k < j; k++) {
////////////                    dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j] + values[i] * values[k] * values[j]);
////////////                }
////////////            }
////////////        }
////////////        return dp[0][n - 1];
////////////    }
////////////
////////////    private int f1(int[] values, int i, int j, int[][] dp) {
////////////        if (i + 1 == j) return 0;
////////////        if (dp[i][j] != -1) return dp[i][j];
////////////        int ans = Integer.MAX_VALUE;
////////////        for (int k = i + 1; k < j; k++) {
////////////            ans = Math.min(ans, f1(values, i, k, dp) + f1(values, k, j, dp) + values[i] * values[k] * values[j]);
////////////        }
////////////        dp[i][j] = ans;
////////////        return ans;
////////////    }
////////////
////////////    public boolean predictTheWinner(int[] nums) {
////////////        int sum = 0;
////////////        for (int num : nums) {
////////////            sum += num;
////////////        }
////////////        int n = nums.length;
////////////        int[][] dp = new int[n][n];
////////////        for (int l = 0; l < n - 1; l++) {
////////////            dp[l][l] = nums[l];
////////////            dp[l][l + 1] = Math.max(nums[l], nums[l + 1]);
////////////        }
////////////        for (int l = n - 3; l >= 0; l--) {
////////////            for (int r = l + 2; r < n; r++) {
////////////                int p1 = nums[l] + Math.min(dp[l + 2][r], dp[l + 1][r - 1]);
////////////                int p2 = nums[r] + Math.min(dp[l + 1][r - 1], dp[l][r - 2]);
////////////                dp[l][r] = Math.max(p1, p2);
////////////            }
////////////        }
////////////        int first = dp[0][n - 1];
////////////        int second = sum - first;
////////////        return first >= second;
////////////    }
////////////
////////////    private int f(int[] nums, int l, int r, int[][] dp) {
////////////        if (l == r) {
////////////            return nums[l];
////////////        }
////////////        if (dp[l][r] != -1) return dp[l][r];
////////////        if (l + 1 == r) {
////////////            return Math.max(nums[l], nums[r]);
////////////        }
////////////        int p1 = nums[l] + Math.min(f(nums, l + 2, r, dp), f(nums, l + 1, r - 1, dp));
////////////        int p2 = nums[r] + Math.min(f(nums, l + 1, r - 1, dp), f(nums, l, r - 2, dp));
////////////        dp[l][r] = Math.max(p1, p2);
////////////        return Math.max(p1, p2);
////////////    }
////////////
////////////    public int minInsertions(String str) {
////////////        int n = str.length();
////////////        char[] s = str.toCharArray();
////////////        int[][] dp = new int[n][n];
////////////        for (int l = 0; l < n - 1; l++) {
////////////            dp[l][l + 1] = s[l] == s[l + 1] ? 0 : 1;
////////////        }
////////////        for (int l = n - 3; l >= 0; l--) {
////////////            for (int r = l + 2; r < n; r++) {
////////////                if (s[l] == s[r]) {
////////////                    dp[l][r] = dp[l + 1][r - 1];
////////////                } else {
////////////                    dp[l][r] = Math.min(dp[l + 1][r], dp[l][r - 1]) + 1;
////////////                }
////////////            }
////////////        }
////////////        return dp[0][n - 1];
////////////    }
////////////
////////////    private int f(char[] s, int l, int r, int[][] dp) {
////////////        if (l == r) return 0;
////////////        if (dp[l][r] != -1) return dp[l][r];
////////////        if (l + 1 == r) {
////////////            return s[l] == s[r] ? 0 : 1;
////////////        }
////////////        int ans = 0;
////////////        if (s[l] == s[r]) {
////////////            ans = f(s, l + 1, r - 1, dp);
////////////        } else {
////////////            ans = Math.min(f(s, l + 1, r, dp), f(s, l, r - 1, dp)) + 1;
////////////        }
////////////        dp[l][r] = ans;
////////////        return ans;
////////////    }
////////////
////////////
//////////////
//////////////    public static int[] move = new int[]{-1, 0, 1, 0, -1};
//////////////
//////////////    public int minTimeToReach(int[][] moveTime) {
//////////////        int n = moveTime.length;
//////////////        int m = moveTime[0].length;
//////////////        return minDistance1(moveTime, 0, 0, n - 1, m - 1);
//////////////    }
//////////////
//////////////    public static int minDistance1(int[][] grid, int startX, int startY, int targetX, int targetY) {
//////////////        int n = grid.length;
//////////////        int m = grid[0].length;
//////////////        int[][] distance = new int[n][m];
//////////////        for (int i = 0; i < n; i++) {
//////////////            for (int j = 0; j < m; j++) {
//////////////                distance[i][j] = Integer.MAX_VALUE;
//////////////            }
//////////////        }
//////////////        distance[startX][startY] = 0;
//////////////        boolean[][] visited = new boolean[n][m];
//////////////        PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[2] - b[2]);
//////////////        heap.add(new int[]{startX, startY, 0});
//////////////        while (!heap.isEmpty()) {
//////////////            int[] cur = heap.poll();
//////////////            int x = cur[0];
//////////////            int y = cur[1];
//////////////            int d = cur[2];
//////////////            if (visited[x][y]) {
//////////////                continue;
//////////////            }
//////////////            if (d > distance[x][y]) {
//////////////                continue;
//////////////            }
//////////////            visited[x][y] = true;
//////////////            if (x == targetX && y == targetY) {
//////////////                return distance[x][y];
//////////////            }
//////////////            for (int i = 0, nx, ny; i < 4; i++) {
//////////////                nx = x + move[i];
//////////////                ny = y + move[i + 1];
//////////////                if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
//////////////                    int newDistance = Math.max(grid[nx][ny], d) + (x + y) % 2 + 1;
//////////////                    if (newDistance < distance[nx][ny]) {
//////////////                        distance[x][y] = newDistance;
//////////////                        heap.add(new int[]{nx,ny,newDistance});
//////////////                    }
//////////////                }
//////////////            }
//////////////        }
//////////////        return -1;
//////////////    }
//////////////
//////////////    public long dfs(int[][] moveTime, boolean[][] visited, int x, int y, int n, int m, long cur, long[][] dp) {
//////////////        if (x == n - 1 && y == m - 1) {
//////////////            return cur;
//////////////        }
//////////////        if (x < 0 || x >= n || y < 0 || y >= m || visited[x][y]) {
//////////////            return Integer.MAX_VALUE - 10000;
//////////////        }
//////////////        visited[x][y] = true;
//////////////        long a = Integer.MAX_VALUE;
//////////////        long b = Integer.MAX_VALUE;
//////////////        long c = Integer.MAX_VALUE;
//////////////        long d = Integer.MAX_VALUE;
//////////////        if (x + 1 < n && cur < moveTime[x + 1][y]) {
//////////////            a = dfs(moveTime, visited, x + 1, y, n, m, moveTime[x + 1][y] + 1, dp);
//////////////            dp[x + 1][y] = dp[x + 1][y] != -1 ? Math.min(a, dp[x + 1][y]) : a;
//////////////        } else {
//////////////            a = dfs(moveTime, visited, x + 1, y, n, m, cur + 1, dp);
//////////////        }
//////////////        if (x - 1 >= 0 && cur < moveTime[x - 1][y]) {
//////////////            b = dfs(moveTime, visited, x - 1, y, n, m, moveTime[x - 1][y] + 1, dp);
//////////////            dp[x - 1][y] = dp[x - 1][y] != -1 ? Math.min(a, dp[x - 1][y]) : a;
//////////////        } else {
//////////////            b = dfs(moveTime, visited, x - 1, y, n, m, cur + 1, dp);
//////////////        }
//////////////        if (y + 1 < m && cur < moveTime[x][y + 1]) {
//////////////            c = dfs(moveTime, visited, x, y + 1, n, m, moveTime[x][y + 1] + 1, dp);
//////////////            dp[x][y + 1] = dp[x][y + 1] != -1 ? Math.min(a, dp[x][y + 1]) : a;
//////////////        } else {
//////////////            c = dfs(moveTime, visited, x, y + 1, n, m, cur + 1, dp);
//////////////        }
//////////////        if (y - 1 >= 0 && cur < moveTime[x][y - 1]) {
//////////////            d = dfs(moveTime, visited, x, y - 1, n, m, moveTime[x][y - 1] + 1, dp);
//////////////            dp[x][y - 1] = dp[x][y - 1] != -1 ? Math.min(a, dp[x][y - 1]) : a;
//////////////        } else {
//////////////            d = dfs(moveTime, visited, x, y - 1, n, m, cur + 1, dp);
//////////////        }
//////////////        visited[x][y] = false;
//////////////        long ans = Math.min(a, Math.min(b, Math.min(c, d)));
//////////////        dp[x][y] = dp[x][y] != -1 ? Math.max(ans, dp[x][y]) : ans;
//////////////        return ans;
//////////////    }
//////////////
//////////////
//////////////    class Solution {
//////////////        public int ans = 0x3f3f3f3f;
//////////////
//////////////        public List<Integer> price, needs;
//////////////
//////////////        public List<List<Integer>> special;
//////////////
//////////////        public Map<Integer, Integer> map = new HashMap<>();
//////////////
//////////////        public int n, m;
//////////////
//////////////        public int shoppingOffers(List<Integer> p, List<List<Integer>> s, List<Integer> need) {
//////////////            price = p;
//////////////            special = s;
//////////////            needs = need;
//////////////            n = price.size();
//////////////            List<Integer> temp = new ArrayList<>();
//////////////            for (int i = 0; i < n; i++)
//////////////                temp.add(0);
//////////////            for (int i = 0; i < n; i++) {
//////////////                List<Integer> clone = new ArrayList<>(temp);
//////////////                clone.set(i, 1);
//////////////                clone.add(price.get(i));
//////////////                special.add(clone);
//////////////            }
//////////////            m = special.size();
//////////////            for (int i = 0; i < m; i++) {
//////////////                List<Integer> x = special.get(i);
//////////////                int k = 0;
//////////////                for (int j = 0; j < n; j++) {
//////////////                    int a = x.get(j), b = needs.get(j);
//////////////                    if (a == 0 || b == 0)
//////////////                        continue;
//////////////                    if (a > b) {
//////////////                        k = 0;
//////////////                        break;
//////////////                    }
//////////////                    k = k == 0 ? b / a : Math.min(k, b / a);
//////////////                }
//////////////                map.put(i, k);
//////////////            }
//////////////            dfs(0, needs, 0);
//////////////            return ans;
//////////////        }
//////////////
//////////////        public void dfs(int u, List<Integer> list, int cur) {
//////////////            if (cur >= ans)
//////////////                return;
//////////////            int cnt = 0;
//////////////            for (int i = 0; i < n; i++)
//////////////                cnt += list.get(i);
//////////////            if (cnt == 0) {
//////////////                ans = cur;
//////////////                return;
//////////////            }
//////////////            if (u == m)
//////////////                return;
//////////////            List<Integer> x = special.get(u);
//////////////            out:
//////////////            for (int k = 0; k <= map.get(u); k++) {
//////////////                List<Integer> clist = new ArrayList<>(list);
//////////////                for (int i = 0; i < n; i++) {
//////////////                    int a = x.get(i), b = clist.get(i);
//////////////                    if (a * k > b)
//////////////                        break out;
//////////////                    clist.set(i, b - a * k);
//////////////                }
//////////////                dfs(u + 1, clist, cur + k * x.get(n));
//////////////            }
//////////////        }
//////////////    }
//////////////
//////////////    public static int MOD = 1000000007;
//////////////
//////////////    public static int MAX_N = 1005;
//////////////
//////////////    public static int[] father = new int[MAX_N];
//////////////
//////////////    public static int cnt;
//////////////
//////////////    public static int find(int x) {
//////////////        if (x != father[x]) {
//////////////            father[x] = find(father[x]);
//////////////        }
//////////////        return father[x];
//////////////    }
//////////////
//////////////    public static void union(int x, int y) {
//////////////        int fx = find(x);
//////////////        int fy = find(y);
//////////////        if (fx != fy) {
//////////////            father[fx] = fy;
//////////////            cnt--;
//////////////        }
//////////////    }
//////////////
//////////////    public static boolean isSameSet(int x, int y) {
//////////////        return find(x) == find(y);
//////////////    }
//////////////
//////////////    public static void build(int n) {
//////////////        for (int i = 0; i <= n; i++) {
//////////////            father[i] = i;
//////////////        }
//////////////        cnt = n;
//////////////    }
//////////////
//////////////    public int findCircleNum(int[][] isConnected) {
//////////////        int n = isConnected.length;
//////////////        build(n);
//////////////        for (int i = 1; i <= n; i++) {
//////////////            for (int j = 1; j <= n; j++) {
//////////////                if (isConnected[i][j] == 1) {
//////////////                    union(i, j);
//////////////                }
//////////////            }
//////////////        }
//////////////        return cnt;
//////////////    }
//////////////
//////////////    public int[] findRedundantConnection(int[][] edges) {
//////////////        int[] ret = new int[2];
//////////////        for (int[] edge : edges) {
//////////////            int from = edge[0];
//////////////            int to = edge[1];
//////////////            if (isSameSet(from, to)) {
//////////////                ret[0] = from;
//////////////                ret[1] = to;
//////////////            } else {
//////////////                union(from, to);
//////////////            }
//////////////        }
//////////////        return ret;
//////////////    }
//////////////
//////////////    public int maxValueOfCoins(List<List<Integer>> piles, int m) {
//////////////        int n = piles.size();
//////////////        int[] dp = new int[m + 1];
//////////////        for (List<Integer> cur : piles) {
//////////////            int t = Math.min(m, cur.size());
//////////////            int[] preSum = new int[t + 1];
//////////////            int sum = 0;
//////////////            for (int j = 0; j < t; j++) {
//////////////                sum += cur.get(j);
//////////////                preSum[j + 1] = sum;
//////////////            }
//////////////            for (int j = m; j >= 0; j--) {
//////////////                for (int k = 1; k <= Math.min(t, j); k++) {
//////////////                    dp[j] = Math.max(dp[j], dp[j - k] + preSum[k]);
//////////////                }
//////////////            }
//////////////        }
//////////////        return dp[m];
//////////////    }
//////////////
//////////////    public int lastStoneWeightII(int[] stones) {
//////////////        int sum = 0;
//////////////        for (int stone : stones) {
//////////////            sum += stone;
//////////////        }
//////////////        int small = f2(stones, sum / 2);
//////////////        return sum - 2 * small;
//////////////    }
//////////////
//////////////    private int f2(int[] stones, int t) {
//////////////        int[] dp = new int[t + 1];
//////////////        for (int stone : stones) {
//////////////            for (int j = t; j >= stone; j++) {
//////////////                dp[j] = Math.max(dp[j], dp[j - stone] + stone);
//////////////            }
//////////////        }
//////////////        return dp[t];
//////////////    }
//////////////
//////////////    public int findTargetSumWays(int[] nums, int target) {
//////////////        int sum = 0;
//////////////        for (int n : nums) {
//////////////            sum += n;
//////////////        }
//////////////        if (sum < target || ((target & 1) ^ (sum & 1)) == 1) {
//////////////            return 0;
//////////////        }
//////////////        return f(nums, (target + sum) >> 1);
//////////////
//////////////    }
//////////////
//////////////    private int f(int[] nums, int t) {
//////////////        if (t < 0) return 0;
//////////////        int[] dp = new int[t + 1];
//////////////        dp[0] = 1;
//////////////        for (int num : nums) {
//////////////            for (int j = t; j >= num; j--) {
//////////////                dp[j] += dp[j - num];
//////////////            }
//////////////        }
//////////////        return dp[t];
//////////////    }
//////////////
//////////////    public int findLongestChain(int[][] pairs) {
//////////////        Arrays.sort(pairs, (a, b) -> a[1] - b[1]);
//////////////        int len = 0;
//////////////        int pre = Integer.MIN_VALUE;
//////////////        for (int[] pair : pairs) {
//////////////            if (pre < pair[0]) {
//////////////                pre = pair[1];
//////////////                len++;
//////////////            }
//////////////        }
//////////////        return len;
//////////////    }
//////////////
//////////////    public int bs(int[] ends, int len, int target) {
//////////////        int left = 0, right = len - 1;
//////////////        int ans = -1;
//////////////        while (left <= right) {
//////////////            int mid = (left + right) / 2;
//////////////            if (ends[mid] >= target) {
//////////////                ans = mid;
//////////////                right = mid - 1;
//////////////            } else {
//////////////                left = mid + 1;
//////////////            }
//////////////        }
//////////////        return ans;
//////////////    }
//////////////
//////////////    public int minChanges(int n, int k) {
//////////////        if ((n & k) != k) return -1;
//////////////        int ans = 0;
//////////////        n = n ^ k;
//////////////        while (n > 0) {
//////////////            int x = n & (-n);
//////////////            n -= x;
//////////////            ans++;
//////////////        }
//////////////        Integer.bitCount(n ^ k);
//////////////        return ans;
//////////////    }
//////////////
//////////////    public int lengthOfLIS(int[] nums) {
//////////////        int n = nums.length;
//////////////        int ans = 0;
//////////////        int[] dp = new int[n];
//////////////        for (int i = 0; i < n; i++) {
//////////////            dp[0] = 1;
//////////////            for (int j = 0; j < i; j++) {
//////////////                if (nums[i] > nums[j]) {
//////////////                    dp[i] = Math.max(dp[i], 1 + dp[j]);
//////////////                }
//////////////            }
//////////////            ans = Math.max(ans, dp[i]);
//////////////        }
//////////////        return ans;
//////////////    }
//////////////
//////////////    public int maxProduct(int[] nums) {
//////////////        int ans = 0;
//////////////        int max = nums[0];
//////////////        int min = nums[0];
//////////////        for (int i = 1, curmin, curmax; i < nums.length; i++) {
//////////////            curmin = Math.min(nums[i], Math.min(max * nums[i], min * nums[i]));
//////////////            curmax = Math.max(nums[i], Math.max(max * nums[i], min * nums[i]));
//////////////            min = curmin;
//////////////            max = curmax;
//////////////            ans = Math.max(ans, max);
//////////////        }
//////////////        return ans;
//////////////    }
//////////////
//////////////    public int[] getMaxMatrix(int[][] matrix) {
//////////////        int n = matrix.length;
//////////////        int m = matrix[0].length;
//////////////        int maxValue = Integer.MIN_VALUE;
//////////////        int a = 0, b = 0, c = 0, d = 0;
//////////////        int[] nums = new int[m];
//////////////        for (int up = 0; up < n; up++) {
//////////////            Arrays.fill(nums, 0);
//////////////            for (int down = up; down < n; down++) {
//////////////                for (int l = 0, r = 0, pre = Integer.MIN_VALUE; r < m; r++) {
//////////////                    nums[r] += matrix[down][r];
//////////////                    pre = Math.max(pre, 0) + nums[r];
//////////////                    if (pre >= 0) {
//////////////                        pre += nums[r];
//////////////                    } else {
//////////////                        pre = nums[r];
//////////////                        l = r;
//////////////                    }
//////////////                    if (pre > maxValue) {
//////////////                        maxValue = pre;
//////////////                        a = up;
//////////////                        b = l;
//////////////                        c = down;
//////////////                        d = r;
//////////////                    }
//////////////                }
//////////////            }
//////////////        }
//////////////        return new int[]{a, b, c, d};
//////////////    }
//////////////
//////////////    public int minCapability(int[] nums, int k) {
//////////////        int n = nums.length;
//////////////        int l = nums[0];
//////////////        int r = nums[0];
//////////////        for (int i = 1; i < n; i++) {
//////////////            l = Math.min(l, nums[i]);
//////////////            r = Math.max(r, nums[i]);
//////////////        }
//////////////        int ans = 0;
//////////////        while (l <= r) {
//////////////            int mid = (l + r) / 2;
//////////////            if (mostRob(nums, n, mid) >= k) {
//////////////                ans = mid;
//////////////                r = mid - 1;
//////////////            } else {
//////////////                l = mid + 1;
//////////////            }
//////////////        }
//////////////        return ans;
//////////////    }
//////////////
//////////////    private int mostRob(int[] nums, int n, int abality) {
//////////////        if (n == 1) {
//////////////            return nums[0] <= abality ? 1 : 0;
//////////////        }
//////////////        if (n == 2) {
//////////////            return (nums[0] <= abality || nums[1] <= abality) ? 1 : 0;
//////////////        }
//////////////        int prepre = nums[0] <= abality ? 1 : 0;
//////////////        int pre = (nums[0] <= abality || nums[1] <= abality) ? 1 : 0;
//////////////        for (int i = 2, cur; i < n; i++) {
//////////////            cur = Math.max(pre, prepre + (nums[i] <= abality ? 1 : 0));
//////////////            prepre = pre;
//////////////            pre = cur;
//////////////        }
//////////////        return pre;
//////////////    }
//////////////
//////////////    private int mostRob2(int[] nums, int n, int abality) {
//////////////        int ans = 0;
//////////////        for (int i = 0; i < n; i++) {
//////////////            if (nums[i] <= abality) {
//////////////                ans++;
//////////////                i++;
//////////////            }
//////////////        }
//////////////        return ans;
//////////////    }
//////////////
//////////////    public int rob(int[] nums) {
//////////////        int n = nums.length;
//////////////        if (n == 1) {
//////////////            return nums[0];
//////////////        }
//////////////        return Math.max(best(nums, 1, n - 1), nums[0] + best(nums, 2, n - 2));
//////////////    }
//////////////
//////////////    public int best(int[] nums, int l, int r) {
//////////////        if (l > r) return 0;
//////////////        if (l == r) return nums[l];
//////////////        if (l + 1 == r) return Math.max(nums[l], nums[r]);
//////////////        int prepre = nums[l];
//////////////        int pre = Math.max(nums[l], nums[l + 1]);
//////////////        for (int i = l + 2, cur; i <= r; i++) {
//////////////            cur = Math.max(pre, nums[i] + Math.max(0, prepre));
//////////////            prepre = pre;
//////////////            pre = cur;
//////////////        }
//////////////        return pre;
//////////////    }
//////////////
//////////////    public int maxSubarraySumCircular(int[] nums) {
//////////////        int n = nums.length;
//////////////        int maxSum = nums[0];
//////////////        int all = nums[0];
//////////////        int minSum = nums[0];
//////////////        for (int i = 1, maxPre = nums[0], minPre = nums[0]; i < n; i++) {
//////////////            all += nums[i];
//////////////            maxPre = Math.max(maxPre + nums[i], nums[i]);
//////////////            maxSum = Math.max(maxPre, maxSum);
//////////////            minPre = Math.min(minPre + nums[i], nums[i]);
//////////////            minSum = Math.min(minPre, minSum);
//////////////        }
//////////////        return all == minSum ? maxSum : Math.max(all - minSum, maxSum);
//////////////    }
//////////////
//////////////    public int maxSubArray(int[] nums) {
//////////////        int n = nums.length;
//////////////        int ans = 0;
//////////////        for (int i = 1, pre = nums[0]; i < n; i++) {
//////////////            pre = Math.max(pre + nums[i], nums[i]);
//////////////            ans = Math.max(ans, pre);
//////////////        }
//////////////        return ans;
//////////////    }
//////////////
//////////////    public long maxEnergyBoost(int[] energyDrinkA, int[] energyDrinkB) {
//////////////        int n = energyDrinkA.length;
//////////////        long a = 0, b = 0, c = 0, d = 0;
//////////////        long tmp1, tmp2;
//////////////        for (int i = 0; i < n; i++) {
//////////////            tmp1 = b;
//////////////            tmp2 = c;
//////////////            b = Math.max(b, c) + energyDrinkA[i];
//////////////            d = Math.max(d, a) + energyDrinkB[i];
//////////////            a = tmp1;
//////////////            c = tmp2;
//////////////        }
//////////////        return Math.max(c, d);
//////////////    }
//////////////
//////////////    public int numberOfPaths(int[][] grid, int k) {
//////////////        int n = grid.length;
//////////////        int m = grid[0].length;
//////////////        int[][][] dp = new int[n][m][k];
//////////////        for (int i = 0; i < n; i++) {
//////////////            for (int j = 0; j < m; j++) {
//////////////                for (int t = 0; t < k; t++) {
//////////////                    dp[i][j][t] = -1;
//////////////                }
//////////////            }
//////////////        }
//////////////        return f(grid, n, m, k, 0, 0, 0, dp);
//////////////    }
//////////////
//////////////    private int f(int[][] grid, int n, int m, int k, int i, int j, int r, int[][][] dp) {
//////////////        if (i == n - 1 && j == m - 1) {
//////////////            return grid[i][j] % k == r ? 1 : 0;
//////////////        }
//////////////        if (dp[i][j][r] != -1) {
//////////////            return dp[i][j][r];
//////////////        }
//////////////        int need = (k + r - (grid[i][j] % k)) % k;
//////////////        int ans = 0;
//////////////        if (i + 1 < n) {
//////////////            ans = f(grid, n, m, k, i + 1, j, need, dp);
//////////////        }
//////////////        if (j + 1 < m) {
//////////////            ans = (ans + f(grid, n, m, k, i, j + 1, need, dp)) % MOD;
//////////////        }
//////////////        dp[i][j][r] = ans;
//////////////        return ans;
//////////////    }
//////////////
//////////////    public double knightProbability(int n, int k, int row, int column) {
//////////////        double[][][] dp = new double[n + 1][n + 1][k + 1];
//////////////        for (int i = 0; i <= n; i++) {
//////////////            for (int j = 0; j <= n; j++) {
//////////////                for (int t = 0; t <= k; t++) {
//////////////                    dp[i][j][t] = -1;
//////////////                }
//////////////            }
//////////////        }
//////////////        return f(n, row, column, k, dp);
//////////////    }
//////////////
//////////////    private double f(int n, int i, int j, int k, double[][][] dp) {
//////////////        if (i < 0 || i >= n || j < 0 || j >= n)
//////////////            return 0;
//////////////        if (dp[i][j][k] != -1) {
//////////////            return dp[i][j][k];
//////////////        }
//////////////        double ans = 0;
//////////////        if (k == 0) {
//////////////            ans = 1;
//////////////        } else {
//////////////            ans += (f(n, i - 2, j + 1, k - 1, dp) / 8);
//////////////            ans += (f(n, i - 1, j + 2, k - 1, dp) / 8);
//////////////            ans += (f(n, i + 1, j + 2, k - 1, dp) / 8);
//////////////            ans += (f(n, i + 2, j + 1, k - 1, dp) / 8);
//////////////            ans += (f(n, i + 2, j - 1, k - 1, dp) / 8);
//////////////            ans += (f(n, i + 1, j - 2, k - 1, dp) / 8);
//////////////            ans += (f(n, i - 1, j - 2, k - 1, dp) / 8);
//////////////            ans += (f(n, i - 2, j - 1, k - 1, dp) / 8);
//////////////        }
//////////////        dp[i][j][k] = ans;
//////////////        return ans;
//////////////    }
//////////////
//////////////
//////////////    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
//////////////        int[][] dp = new int[n + 1][minProfit + 1];
//////////////        for (int i = 0; i <= n; i++) {
//////////////            dp[i][0] = 1;
//////////////        }
//////////////        int m = group.length;
//////////////        for (int i = m - 1; i >= 0; i--) {
//////////////            for (int r = n; r >= 0; r--) {
//////////////                for (int s = minProfit; s >= 0; s--) {
//////////////                    int p1 = dp[r][s];
//////////////                    int p2 = group[i] <= r ? dp[r - group[i]][Math.max(0, s - profit[i])] : 0;
//////////////                    dp[r][s] = (p1 + p2) % MOD;
//////////////                }
//////////////            }
//////////////        }
//////////////        return dp[n][minProfit];
//////////////    }
//////////////
//////////////    private int f(int[] group, int[] profit, int i, int restPeople, int restProfit, int[][][] dp) {
//////////////        if (restPeople <= 0) {
//////////////            return restProfit <= 0 ? 1 : 0;
//////////////        }
//////////////        if (i == group.length) {
//////////////            return restProfit <= 0 ? 1 : 0;
//////////////        }
//////////////        if (dp[i][restPeople][restProfit] != -1) {
//////////////            return dp[i][restPeople][restProfit];
//////////////        }
//////////////        int p1 = f(group, profit, i + 1, restPeople, restProfit, dp);
//////////////        int p2 = 0;
//////////////        if (restPeople <= group[i]) {
//////////////            p2 = f(group, profit, i + 1, restPeople - group[i], Math.max(0, restProfit - profit[i]), dp);
//////////////        }
//////////////        int ans = (p1 + p2) % MOD;
//////////////        dp[i][restPeople][restProfit] = ans;
//////////////        return ans;
//////////////    }
//////////////
//////////////    public int zeros, ones;
//////////////
//////////////    public int findMaxForm(String[] strs, int m, int n) {
//////////////        int[][] dp = new int[m + 1][n + 1];
//////////////        for (String str : strs) {
//////////////            countZerosAndOnes(str);
//////////////            for (int z = m; z >= zeros; z--) {
//////////////                for (int o = n; o >= ones; o--) {
//////////////                    dp[z][o] = Math.max(dp[z][o], dp[z - zeros][o - ones] + 1);
//////////////                }
//////////////            }
//////////////        }
//////////////        return dp[m][n];
//////////////    }
//////////////
//////////////    private int f(String[] strs, int i, int m, int n, int[][][] dp) {
//////////////        if (i == strs.length) {
//////////////            return 0;
//////////////        }
//////////////        if (dp[i][m][n] != -1) {
//////////////            return dp[i][m][n];
//////////////        }
//////////////        int p1 = f(strs, i + 1, m, n, dp);
//////////////        countZerosAndOnes(strs[i]);
//////////////        int p2 = 0;
//////////////        countZerosAndOnes(strs[i]);
//////////////        if (zeros <= m && ones <= n) {
//////////////            p2 = 1 + f(strs, i + 1, m - zeros, n - ones, dp);
//////////////        }
//////////////        int ans = Math.max(p1, p2);
//////////////        dp[i][m][n] = ans;
//////////////        return ans;
//////////////    }
//////////////
//////////////    private void countZerosAndOnes(String str) {
//////////////        zeros = 0;
//////////////        ones = 0;
//////////////        for (int i = 0; i < str.length(); i++) {
//////////////            if (str.charAt(i) == '0') {
//////////////                zeros++;
//////////////            } else {
//////////////                ones++;
//////////////            }
//////////////        }
//////////////    }
//////////////
////////////////
////////////////    public static int MOD = 1000000007;
////////////////
////////////////    public static int MAX_N = 50005;
////////////////
////////////////    public static long[][] t = new long[MAX_N][4];
////////////////
////////////////    public int maximumSumSubsequence(int[] nums, int[][] queries) {
////////////////        int n = nums.length;
////////////////        build(nums, 1, 0, n - 1);
////////////////
////////////////        long ans = 0;
////////////////        for (int[] q : queries) {
////////////////            update(1, 0, n - 1, q[0], q[1]);
////////////////            ans += t[1][3];
////////////////        }
////////////////        return (int) (ans % MOD);
////////////////    }
////////////////
////////////////    private void maintain(int o) {
////////////////        long[] a = t[o * 2];
////////////////        long[] b = t[o * 2 + 1];
////////////////        t[o][0] = Math.max(a[0] + b[2], a[1] + b[0]);
////////////////        t[o][1] = Math.max(a[0] + b[3], a[1] + b[1]);
////////////////        t[o][2] = Math.max(a[2] + b[2], a[3] + b[0]);
////////////////        t[o][3] = Math.max(a[2] + b[3], a[3] + b[1]);
////////////////    }
////////////////    private void build(int[] nums, int o, int l, int r) {
////////////////        if (l == r) {
////////////////            t[o][3] = Math.max(nums[l], 0);
////////////////            return;
////////////////        }
////////////////        int m = (l + r) / 2;
////////////////        build(nums, o * 2, l, m);
////////////////        build(nums, o * 2 + 1, m + 1, r);
////////////////        maintain(o);
////////////////    }
////////////////    private void update(int o, int l, int r, int i, int val) {
////////////////        if (l == r) {
////////////////            t[o][3] = Math.max(val, 0);
////////////////            return;
////////////////        }
////////////////        int m = (l + r) / 2;
////////////////        if (i <= m) {
////////////////            update(o * 2, l, m, i, val);
////////////////        } else {
////////////////            update(o * 2 + 1, m + 1, r, i, val);
////////////////        }
////////////////        maintain(o);
////////////////    }
////////////////
////////////////    public boolean isInterleave(String str1, String str2, String str3) {
////////////////        int n = str1.length();
////////////////        int m = str2.length();
////////////////        if (n + m != str3.length()) {
////////////////            return false;
////////////////        }
////////////////        char[] s1 = str1.toCharArray();
////////////////        char[] s2 = str2.toCharArray();
////////////////        char[] s3 = str3.toCharArray();
////////////////        boolean[][] dp = new boolean[n + 1][m + 1];
////////////////        dp[0][0] = true;
////////////////        for (int i = 1; i <= n; i++) {
////////////////            if (s1[i - 1] != s3[i - 1]) {
////////////////                break;
////////////////            }
////////////////            dp[i][0] = true;
////////////////        }
////////////////        for (int j = 1; j <= m; j++) {
////////////////            if (s2[j - 1] != s3[j - 1]) {
////////////////                break;
////////////////            }
////////////////            dp[0][j] = true;
////////////////        }
////////////////        for (int i = 1; i <= n; i++) {
////////////////            for (int j = 1; j <= m; j++) {
////////////////                dp[i][j] = (s1[i - 1] == s3[i + j - 1] && dp[i - 1][j]) || (s2[j - 1] == s3[i + j - 1] && dp[i][j - 1]);
////////////////            }
////////////////        }
////////////////        return dp[n][m];
////////////////    }
////////////////
////////////////    public int minDistance(String word1, String word2) {
////////////////        return editDistance(word1, word2, 1, 1, 1);
////////////////    }
////////////////
////////////////    public int editDistance(String word1, String word2, int a, int b, int c) {
////////////////        int n = word1.length();
////////////////        int m = word2.length();
////////////////        char[] s1 = word1.toCharArray();
////////////////        char[] s2 = word2.toCharArray();
////////////////        int[][] dp = new int[n + 1][m + 1];
////////////////        for (int i = 1; i <= n; i++) {
////////////////            dp[i][0] = i * b;
////////////////        }
////////////////        for (int i = 1; i <= m; i++) {
////////////////            dp[0][i] = i * a;
////////////////        }
////////////////        for (int i = 1; i <= n; i++) {
////////////////            for (int j = 1; j <= m; j++) {
////////////////                if (s2[i - 1] == s1[j - 1]) {
////////////////                    dp[i][j] = dp[i - 1][j - 1];
////////////////                } else {
////////////////                    dp[i][j] = Math.min(Math.min(dp[i - 1][j] + b, dp[i][j - 1] + a), dp[i - 1][j - 1] + c);
////////////////                }
////////////////            }
////////////////        }
////////////////        return dp[n][m];
////////////////    }
////////////////}
////////////////
////////////////
////////////////public int numDistinct(String str, String target) {
////////////////    int n = str.length();
////////////////    int m = target.length();
////////////////    char[] s = str.toCharArray();
////////////////    char[] t = target.toCharArray();
////////////////    int[] dp = new int[m + 1];
////////////////    dp[0] = 1;
////////////////    for (int i = 1; i <= n; i++) {
////////////////        for (int j = m; j >= 1; j--) {
////////////////            if (s[i - 1] == t[j - 1]) {
////////////////                dp[j] += dp[j - 1];
////////////////            }
////////////////        }
////////////////    }
////////////////    return dp[m];
////////////////}
////////////////
////////////////public int rob(int[] nums) {
////////////////    if (nums.length == 1)
////////////////        return nums[0];
////////////////    int a = nums[0];
////////////////    int b = Math.max(nums[0], nums[1]);
////////////////    int c = 0;
////////////////    for (int i = 2; i < nums.length; i++) {
////////////////        c = Math.max(b, a + nums[i]);
////////////////        a = b;
////////////////        b = c;
////////////////    }
////////////////    return c;
////////////////}
////////////////
//////////////////
//////////////////    private static final int MOD = 1000000007;
//////////////////
//////////////////    public int lengthAfterTransformations2(String s, int t) {
//////////////////        long length = s.length();
//////////////////        int zCount = 0;
//////////////////        long ans = 0;
//////////////////        for (char c : s.toCharArray()) {
//////////////////            if (c == 'z') {
//////////////////                zCount++;
//////////////////            }
//////////////////        }
//////////////////        ans = (long) zCount * t % MOD;
//////////////////        ans = (length + ans) % MOD;
//////////////////        return (int) ans;
//////////////////    }
//////////////////
//////////////////    public long maxScore(int[] nums) {
//////////////////        int n = nums.length;
//////////////////        if (n == 0)
//////////////////            return 0;
//////////////////        if (n == 1)
//////////////////            return nums[0] * nums[0];
//////////////////
//////////////////        long overallGCD = nums[0];
//////////////////        long overallLCM = nums[0];
//////////////////        for (int i = 1; i < n; i++) {
//////////////////            overallGCD = gcd(overallGCD, nums[i]);
//////////////////            overallLCM = lcm(overallLCM, nums[i]);
//////////////////        }
//////////////////
//////////////////        long maxScore = overallGCD * overallLCM;
//////////////////
//////////////////        for (int i = 0; i < n; i++) {
//////////////////            long currentGCD = 0;
//////////////////            long currentLCM = 1;
//////////////////            for (int j = 0; j < n; j++) {
//////////////////                if (j != i) {
//////////////////                    currentGCD = (currentGCD == 0) ? nums[j] : gcd(currentGCD, nums[j]);
//////////////////                    currentLCM = lcm(currentLCM, nums[j]);
//////////////////                }
//////////////////            }
//////////////////            maxScore = Math.max(maxScore, currentGCD * currentLCM);
//////////////////        }
//////////////////        return maxScore;
//////////////////    }
//////////////////
//////////////////    private static long gcd(long a, long b) {
//////////////////        while (b != 0) {
//////////////////            long temp = b;
//////////////////            b = a % b;
//////////////////            a = temp;
//////////////////        }
//////////////////        return a;
//////////////////    }
//////////////////
//////////////////    private static long lcm(long a, long b) {
//////////////////        return a * (b / gcd(a, b));
//////////////////    }
//////////////////
//////////////////    private static final int MOD = 1000000007;
//////////////////
//////////////////
//////////////////    private static final int MOD = 1000000007;
//////////////////
//////////////////    public int longestIncreasingPath(int[][] matrix) {
//////////////////        int n = matrix.length;
//////////////////        int m = matrix[0].length;
//////////////////        int[][] dp = new int[n][m];
//////////////////        int ans = 0;
//////////////////        for (int i = 0; i < n; i++) {
//////////////////            for (int j = 0; j < m; j++) {
//////////////////                ans = Math.max(ans, dfs(matrix, i, j, dp));
//////////////////            }
//////////////////        }
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    private int dfs(int[][] matrix, int i, int j, int[][] dp) {
//////////////////        int ans = 0;
//////////////////        if (dp[i][j] != 0) return dp[i][j];
//////////////////        if (i > 0 && matrix[i - 1][j] > matrix[i][j])
//////////////////            ans = Math.max(dfs(matrix, i - 1, j, dp), ans);
//////////////////        if (j > 0 && matrix[i][j - 1] > matrix[i][j])
//////////////////            ans = Math.max(dfs(matrix, i, j - 1, dp), ans);
//////////////////        if (i < matrix.length - 1 && matrix[i + 1][j] > matrix[i][j])
//////////////////            ans = Math.max(dfs(matrix, i + 1, j, dp), ans);
//////////////////        if (j < matrix[0].length - 1 && matrix[i][j + 1] > matrix[i][j])
//////////////////            ans = Math.max(dfs(matrix, i, j + 1, dp), ans);
//////////////////        dp[i][j] = ans + 1;
//////////////////        return ans + 1;
//////////////////    }
//////////////////
//////////////////    public int longestPalindromeSubseq(String str) {
//////////////////        int n = str.length();
//////////////////        char[] s = str.toCharArray();
//////////////////        int[] dp = new int[n];
//////////////////        int leftDown = 0;
//////////////////        int backUp = 0;
//////////////////        for (int l = n - 1; l >= 0; l--) {
//////////////////            dp[l] = 1;
//////////////////            if (l + 1 < n) {
//////////////////                leftDown = dp[l + 1];
//////////////////                dp[l + 1] = (s[l] == s[l + 1]) ? 2 : 1;
//////////////////            }
//////////////////            for (int r = l + 2; r < n; r++) {
//////////////////                backUp = dp[r];
//////////////////                if (s[l] == s[r]) {
//////////////////                    dp[r] = 2 + leftDown;
//////////////////                } else {
//////////////////                    dp[r] = Math.max(dp[r], dp[r - 1]);
//////////////////                }
//////////////////                leftDown = backUp;
//////////////////            }
//////////////////        }
//////////////////        return dp[n - 1];
//////////////////    }
//////////////////
//////////////////    private int f(char[] s, int l, int r, int[][] dp) {
//////////////////        if (l == r) {
//////////////////            return 1;
//////////////////        }
//////////////////        if (l + 1 == r) {
//////////////////            return (s[l] == s[r]) ? 2 : 1;
//////////////////        }
//////////////////        if (dp[l][r] != 0) return dp[l][r];
//////////////////        int ans = 0;
//////////////////        if (s[l] == s[r]) {
//////////////////            ans = 2 + f(s, l + 1, r - 1, dp);
//////////////////        } else {
//////////////////            ans = Math.max(f(s, l + 1, r, dp), f(s, l, r - 1, dp));
//////////////////        }
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    public List<String> validStrings(int n) {
//////////////////        List<String> ans = new ArrayList<>();
//////////////////        char[] path = new char[n];
//////////////////        dfs(ans, path, 0, n);
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    private void dfs(List<String> ans, char[] path, int i, int n) {
//////////////////        if (i == n) {
//////////////////            ans.add(new String(path));
//////////////////            return;
//////////////////        }
//////////////////        path[i] = '1';
//////////////////        dfs(ans, path, i + 1, n);
//////////////////        if (i == 0 || path[i - 1] == '1') {
//////////////////            dfs(ans, path, i + 1, n);
//////////////////        }
//////////////////    }
//////////////////
//////////////////    public int longestCommonSubsequence(String text1, String text2) {
//////////////////        char[] s1, s2;
//////////////////        if (text1.length() > text2.length()) {
//////////////////            s1 = text1.toCharArray();
//////////////////            s2 = text2.toCharArray();
//////////////////        } else {
//////////////////            s1 = text2.toCharArray();
//////////////////            s2 = text1.toCharArray();
//////////////////        }
//////////////////        int n = s1.length;
//////////////////        int m = s2.length;
//////////////////        int[] dp = new int[m + 1];
//////////////////        for (int len1 = 1; len1 <= n; len1++) {
//////////////////            int leftup = 0, backup;
//////////////////            for (int len2 = 1; len2 <= m; len2++) {
//////////////////                backup = dp[len2];
//////////////////                if (s1[len1 - 1] == s2[len2 - 1]) {
//////////////////                    dp[len2] = leftup + 1;
//////////////////                } else {
//////////////////                    dp[len2] = Math.max(dp[len2], dp[len2 - 1]);
//////////////////                }
//////////////////                leftup = backup;
//////////////////            }
//////////////////        }
//////////////////        return dp[m];
//////////////////    }
//////////////////
//////////////////    private int f(char[] s1, char[] s2, int len1, int len2, int[][] dp) {
//////////////////        if (len1 == 0 || len2 == 0) {
//////////////////            return 0;
//////////////////        }
//////////////////        if (dp[len1][len2] != -1) {
//////////////////            return dp[len1][len2];
//////////////////        }
//////////////////        int ans = 0;
//////////////////        if (s1[len1 - 1] == s2[len2 - 1]) {
//////////////////            ans = f(s1, s2, len1 - 1, len2 - 1, dp) + 1;
//////////////////        } else {
//////////////////            ans = Math.max(f(s1, s2, len1 - 1, len2, dp), f(s1, s2, len1, len2 - 1, dp));
//////////////////        }
//////////////////        dp[len1][len2] = ans;
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    public int minPathSum(int[][] grid) {
//////////////////        int m = grid.length;
//////////////////        int n = grid[0].length;
//////////////////        int[] dp = new int[n];
//////////////////        dp[0] = grid[0][0];
//////////////////        for (int j = 1; j < m; j++)
//////////////////            dp[j] = dp[j - 1] + grid[0][j];
//////////////////        for (int i = 1; i < n; i++) {
//////////////////            dp[0] += grid[i][0];
//////////////////            for (int j = 1; j < m; j++) {
//////////////////                dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
//////////////////            }
//////////////////        }
//////////////////        return dp[m - 1];
//////////////////    }
//////////////////
//////////////////    public int distinctSubseqII(String s) {
//////////////////        int[] cnt = new int[26];
//////////////////        int all = 1;
//////////////////        int newAdd = 0;
//////////////////        char[] charArray = s.toCharArray();
//////////////////        for (char c : charArray) {
//////////////////            newAdd = (all - cnt[c - 'a'] + MOD) % MOD;
//////////////////            cnt[c - 'a'] = newAdd;
//////////////////            all = (newAdd + all) % MOD;
//////////////////        }
//////////////////        return (all - 1 + MOD) % MOD;
//////////////////    }
//////////////////
//////////////////    public int findSubstringInWraproundString(String s) {
//////////////////        int n = s.length();
//////////////////        int[] dp = new int[26];
//////////////////        dp[s.charAt(0) - 'a'] = 1;
//////////////////        for (int i = 1, pre, cur, len = 1; i < n; i++) {
//////////////////            pre = s.charAt(i - 1) - 'a';
//////////////////            cur = s.charAt(i) - 'a';
//////////////////            if ((pre + 1) % 26 == 0) {
//////////////////                len++;
//////////////////            } else {
//////////////////                len = 1;
//////////////////            }
//////////////////            dp[cur] = Math.max(len, dp[pre]);
//////////////////        }
//////////////////        int ans = 0;
//////////////////        for (int i = 0; i < 26; i++) {
//////////////////            ans += dp[i];
//////////////////        }
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    class WordDictionary {
//////////////////        public static int MAX_N = 10001;
//////////////////
//////////////////        public static int[][] tree = new int[MAX_N][26];
//////////////////
//////////////////        public static int[] end = new int[MAX_N];
//////////////////
//////////////////        public static int[] pass = new int[MAX_N];
//////////////////
//////////////////        public static int cnt = 0;
//////////////////
//////////////////        public static void insert(String s) {
//////////////////            int cur = 1;
//////////////////            pass[cur]++;
//////////////////            for (int i = 0; i < s.length(); i++) {
//////////////////                int index = s.charAt(i) - 'a';
//////////////////                if (tree[cur][index] == 0) {
//////////////////                    tree[cur][index] = ++cnt;
//////////////////                }
//////////////////                cur = tree[cur][index];
//////////////////            }
//////////////////            end[cur]++;
//////////////////        }
//////////////////
//////////////////        public static boolean searchWord(String s) {
//////////////////            return dfs(s, 0, 1);
//////////////////        }
//////////////////
//////////////////        public static boolean dfs(String s, int index, int node) {
//////////////////            if (index == s.length()) {
//////////////////                return true;
//////////////////            }
//////////////////            if (pass[node] == 0) {
//////////////////                return false;
//////////////////            }
//////////////////            char ch = s.charAt(index);
//////////////////            if (Character.isLetter(ch)) {
//////////////////                int nextNode = ch - 'a';
//////////////////                if (tree[node][nextNode] != 0 && dfs(s, index + 1, tree[node][nextNode])) {
//////////////////                    return true;
//////////////////                }
//////////////////            } else {
//////////////////                for (int i = 0; i < 26; i++) {
//////////////////                    if (tree[node][i] != 0 && dfs(s, index + 1, tree[node][i])) {
//////////////////                        return true;
//////////////////                    }
//////////////////                }
//////////////////            }
//////////////////            return false;
//////////////////        }
//////////////////
//////////////////        public static int startWith(String s) {
//////////////////            int cur = 1;
//////////////////            for (int i = 0; i < s.length(); i++) {
//////////////////                int index = s.charAt(i) - 'a';
//////////////////                if (tree[cur][index] == 0) {
//////////////////                    return 0;
//////////////////                }
//////////////////                cur = tree[cur][index];
//////////////////            }
//////////////////            return pass[cur];
//////////////////        }
//////////////////
//////////////////        public static void build() {
//////////////////            for (int i = 0; i <= cnt; i++) {
//////////////////                Arrays.fill(tree[i], 0);
//////////////////                end[i] = 0;
//////////////////                pass[i] = 0;
//////////////////            }
//////////////////            cnt = 1;
//////////////////        }
//////////////////
//////////////////        public WordDictionary() {
//////////////////            build();
//////////////////        }
//////////////////
//////////////////        public void addWord(String word) {
//////////////////            insert(word);
//////////////////        }
//////////////////
//////////////////        public boolean search(String word) {
//////////////////            return searchWord(word);
//////////////////        }
//////////////////    }
//////////////////
//////////////////
//////////////////    public String longestCommonPrefix(String[] strs) {
//////////////////        build();
//////////////////        for (String s : strs) {
//////////////////            indsert(s);
//////////////////        }
//////////////////        String s = strs[0];
//////////////////        StringBuilder ret = new StringBuilder();
//////////////////        int val = Integer.MIN_VALUE;
//////////////////        for (int i = 0; i < s.length(); i++) {
//////////////////            ret.append(s.charAt(i));
//////////////////            if (startWith(ret.toString()) != strs.length) {
//////////////////                return ret.toString().substring(0, ret.length() - 1);
//////////////////            }
//////////////////        }
//////////////////        return val == 0 ? "" : ret.toString();
//////////////////    }
//////////////////
//////////////////    class Solution {
//////////////////
//////////////////        private int[] father = new int[100005];
//////////////////
//////////////////        public void build(int n) {
//////////////////            for (int i = 0; i < n; i++) {
//////////////////                father[i] = i;
//////////////////            }
//////////////////        }
//////////////////
//////////////////        public void union(int x, int y) {
//////////////////            int rootX = find(x);
//////////////////            int rootY = find(y);
//////////////////            if (rootX != rootY) {
//////////////////                father[x] = rootY;
//////////////////            }
//////////////////        }
//////////////////
//////////////////        public int find(int x) {
//////////////////            if (x != father[x]) {
//////////////////                father[x] = find(father[x]);
//////////////////            }
//////////////////            return father[x];
//////////////////        }
//////////////////
//////////////////        public int[] findRedundantDirectedConnection(int[][] edges) {
//////////////////            int n = edges.length;
//////////////////            int[] inDegree = new int[n + 1];
//////////////////            List<Integer> list = new ArrayList<>();
//////////////////            build(n + 1);
//////////////////            for (int[] edge : edges) {
//////////////////                ++inDegree[edge[1]];
//////////////////            }
//////////////////            for (int i = n - 1; i >= 0; i--) {
//////////////////                if (inDegree[edges[i][1]] == 2) {
//////////////////                    list.add(i);
//////////////////                }
//////////////////            }
//////////////////            if (!list.isEmpty()) {
//////////////////                if (removeEdge(edges, list.get(0))) {
//////////////////                    return edges[list.get(0)];
//////////////////                }
//////////////////                return edges[list.get(1)];
//////////////////            }
//////////////////            return removeCycleEdge(edges);
//////////////////        }
//////////////////
//////////////////        private boolean removeEdge(int[][] edges, Integer delEdge) {
//////////////////            int n = edges.length;
//////////////////            build(n + 1);
//////////////////            for (int i = 0; i < n; i++) {
//////////////////                int[] edge = edges[i];
//////////////////                if (i != delEdge) {
//////////////////                    if (find(edge[0]) == find(edge[1])) {
//////////////////                        return false;
//////////////////                    }
//////////////////                    union(edge[0], edge[1]);
//////////////////                }
//////////////////            }
//////////////////            return true;
//////////////////        }
//////////////////
//////////////////        private int[] removeCycleEdge(int[][] edges) {
//////////////////            int n = edges.length;
//////////////////            build(n + 1);
//////////////////            for (int[] edge : edges) {
//////////////////                if (find(edge[0]) == find(edge[1])) {
//////////////////                    return edge;
//////////////////                }
//////////////////                union(edge[0], edge[1]);
//////////////////            }
//////////////////            return null;
//////////////////        }
//////////////////    }
//////////////////
//////////////////    public int longestValidParentheses(String str) {
//////////////////        char[] s = str.toCharArray();
//////////////////        int[] dp = new int[s.length];
//////////////////        int ans = 0;
//////////////////        for (int i = 1, p; i < s.length; i++) {
//////////////////            if (s[i] == ')') {
//////////////////                p = i - dp[i - 1] - 1;
//////////////////                if (p >= 0 && s[p] == '(') {
//////////////////                    dp[i] = dp[i - 1] + 2 + (p > 0 ? dp[p - 1] : 0);
//////////////////                }
//////////////////            }
//////////////////            ans = Math.max(dp[i], ans);
//////////////////        }
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    public int nthUglyNumber(int n) {
//////////////////        int[] dp = new int[n + 1];
//////////////////        dp[1] = 1;
//////////////////        for (int i = 2, i2 = 1, i3 = 1, i5 = 1, a, b, c, cur; i <= n; i++) {
//////////////////            a = dp[i2] * 2;
//////////////////            b = dp[i3] * 3;
//////////////////            c = dp[i5] * 5;
//////////////////            cur = Math.min(a, Math.min(b, c));
//////////////////            if (cur == a) {
//////////////////                i2++;
//////////////////            }
//////////////////            if (cur == b) {
//////////////////                i3++;
//////////////////            }
//////////////////            if (cur == c) {
//////////////////                i5++;
//////////////////            }
//////////////////            dp[i] = cur;
//////////////////        }
//////////////////        return dp[n];
//////////////////    }
//////////////////
//////////////////    public int numDecodings(String s) {
//////////////////        long[] dp = new long[s.length()];
//////////////////        Arrays.fill(dp, -1);
//////////////////        return (int) f(s.toCharArray(), 0, dp);
//////////////////    }
//////////////////
//////////////////    public int numDecodings2(String str) {
//////////////////        int n = str.length();
//////////////////        char[] s = str.toCharArray();
//////////////////        long[] dp = new long[n + 1];
//////////////////        dp[n] = 1;
//////////////////        for (int i = n - 1; i >= 0; i--) {
//////////////////            if (s[i] != '0') {
//////////////////                dp[i] = dp[i + 1] * (s[i] == '*' ? 9 : 1);
//////////////////                if (i + 1 < n) {
//////////////////                    if (s[i] != '*') {
//////////////////                        if (s[i + 1] != '*') {
//////////////////                            if ((s[i] - '0') * 10 + (s[i + 1] - '0') <= 26) {
//////////////////                                dp[i] += f(s, i + 2, dp) * 1;
//////////////////                            }
//////////////////                        } else {
//////////////////                            if (s[i] == '1') {
//////////////////                                dp[i] += dp[i + 2] * 9;
//////////////////                            } else if (s[i] == '2') {
//////////////////                                dp[i] += dp[i + 2] * 6;
//////////////////                            }
//////////////////                        }
//////////////////                    } else {
//////////////////                        if (s[i + 1] != '*') {
//////////////////                            if (s[i + 1] <= '6') {
//////////////////                                dp[i] += dp[i + 2] * 2;
//////////////////                            } else {
//////////////////                                dp[i] += dp[i + 2] * 1;
//////////////////                            }
//////////////////                        } else {
//////////////////                            dp[i] += dp[i + 2] * 15;
//////////////////                        }
//////////////////                    }
//////////////////                }
//////////////////                dp[i] %= MOD;
//////////////////            }
//////////////////        }
//////////////////        return (int) dp[0];
//////////////////    }
//////////////////
//////////////////    private long f(char[] s, int i, long[] dp) {
//////////////////        if (i == s.length)
//////////////////            return 1;
//////////////////        if (s[i] == '0') return 0;
//////////////////        if (dp[i] != -1) return dp[i];
//////////////////        long ans = f(s, i + 1, dp) * (s[i] == '*' ? 9 : 1);
//////////////////        if (i + 1 < s.length) {
//////////////////            if (s[i] != '*') {
//////////////////                if (s[i + 1] != '*') {
//////////////////                    if ((s[i] - '0') * 10 + (s[i + 1] - '0') <= 26) {
//////////////////                        ans += f(s, i + 2, dp) * 1;
//////////////////                    }
//////////////////                } else {
//////////////////                    if (s[i] == '1') {
//////////////////                        ans += f(s, i + 2, dp) * 9;
//////////////////                    } else if (s[i] == '2') {
//////////////////                        ans += f(s, i + 2, dp) * 6;
//////////////////                    }
//////////////////                }
//////////////////            } else {
//////////////////                if (s[i + 1] != '*') {
//////////////////                    if (s[i + 1] <= '6') {
//////////////////                        ans += f(s, i + 2, dp) * 2;
//////////////////                    } else {
//////////////////                        ans += f(s, i + 2, dp) * 1;
//////////////////                    }
//////////////////                } else {
//////////////////                    ans += f(s, i + 2, dp) * 15;
//////////////////                }
//////////////////            }
//////////////////        }
//////////////////        ans %= MOD;
//////////////////        dp[i] = ans;
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    public int lengthAfterTransformations(String s, int t, List<Integer> nums) {
//////////////////        long ans = 0;
//////////////////        int n = s.length();
//////////////////
//////////////////        long[][] dp = new long[27][t + 1];
//////////////////        for (int i = 0; i < 27; i++) {
//////////////////            dp[i][0] = 1;
//////////////////        }
//////////////////        for (char c : s.toCharArray()) {
//////////////////            Integer count = nums.get(c - 'a');
//////////////////            ans += count - 1;
//////////////////            long cur = 0;
//////////////////            for (int i = 1; i <= count.intValue(); i++) {
//////////////////                if (c + i > 'z') {
//////////////////                    cur += dp[c + i - 26 - 'a'][t - 1];
//////////////////                    // ans += dfs(dp, (char) (c + i - 26), t - 1, nums);
//////////////////                } else {
//////////////////                    //ans += dfs(dp, (char) (c + i), t - 1, nums);
//////////////////                    cur += dp[c + i - 'a'][t - 1];
//////////////////                }
//////////////////                dp[c - 'a' + i][t] = cur;
//////////////////            }
//////////////////            ans += cur;
//////////////////            ans %= MOD;
//////////////////        }
//////////////////        return (int) ans + n;
//////////////////    }
//////////////////
//////////////////    private long dfs(long[][] dp, char c, int t, List<Integer> nums) {
//////////////////        if (t <= 0) {
//////////////////            return 0;
//////////////////        }
//////////////////        if (dp[c - 'a'][t] != -1)
//////////////////            return dp[c - 'a'][t];
//////////////////        long ans = 0;
//////////////////        Integer count = nums.get(c - 'a');
//////////////////        ans += count - 1;
//////////////////        for (int i = 1; i <= count.intValue(); i++) {
//////////////////            if (c + i > 'z') {
//////////////////                ans += dfs(dp, (char) (c + i - 26), t - 1, nums);
//////////////////            } else {
//////////////////                ans += dfs(dp, (char) (c + i), t - 1, nums);
//////////////////            }
//////////////////        }
//////////////////        dp[c - 'a'][t] = ans;
//////////////////        return ans;
//////////////////    }
//////////////////
//////////////////    public int lengthAfterTransformations(String s, int t) {
//////////////////        long ans = 0;
//////////////////        int n = s.length();
//////////////////        int[][] dp = new int[27][t + 1];
//////////////////        for (int i = 0; i < 27; i++)
//////////////////            Arrays.fill(dp[i], -1);
//////////////////        for (char c : s.toCharArray()) {
//////////////////            if (t <= 0) break;
//////////////////            ans += dfs(dp, c, t);
//////////////////            ans %= MOD;
//////////////////        }
//////////////////        return (int) ans + s.length();
//////////////////    }
//////////////////
////////////////////
////////////////////    public static int duration[] = new int[]{1, 7, 30};
////////////////////
////////////////////    public static int[] dp = new int[MAX_N];
////////////////////
////////////////////
////////////////////
////////////////////    public int numEnclaves(int[][] grid) {
////////////////////        int n = grid.length;
////////////////////        int m = grid[0].length;
////////////////////        for (int j = 0; j < m; j++) {
////////////////////            if (grid[0][j] == 1)
////////////////////                dfs(grid, 0, j, n, m);
////////////////////            if (grid[n - 1][j] == 1)
////////////////////                dfs(grid, n - 1, j, n, m);
////////////////////        }
////////////////////        for (int i = 0; i < n; i++) {
////////////////////            if (grid[i][0] == 1)
////////////////////                dfs(grid, i, 0, n, m);
////////////////////            if (grid[i][m - 1] == 1)
////////////////////                dfs(grid, i, m - 1, n, m);
////////////////////        }
////////////////////        int cnt = 0;
////////////////////        for (int i = 0; i < n; i++) {
////////////////////            for (int j = 0; j < m; j++) {
////////////////////                if (grid[i][j] == 1) cnt++;
////////////////////                if (grid[i][j] == 2) grid[i][j] = 1;
////////////////////            }
////////////////////        }
////////////////////        return cnt;
////////////////////    }
////////////////////
////////////////////    private void dfs(int[][] grid, int i, int j, int n, int m) {
////////////////////        if (i < 0 || i >= n || j < 0 || j >= m || grid[i][j] != 1) return;
////////////////////        grid[i][j] = 2;
////////////////////        dfs(grid, i + 1, j, n, m);
////////////////////        dfs(grid, i - 1, j, n, m);
////////////////////        dfs(grid, i, j + 1, n, m);
////////////////////        dfs(grid, i, j - 1, n, m);
////////////////////    }
////////////////////
////////////////////    public static int MAX_N = 1005;
////////////////////    public static int[] father = new int[MAX_N];
////////////////////
////////////////////
////////////////////    public static int find(int x) {
////////////////////        if (x != father[x]) {
////////////////////            father[x] = find(father[x]);
////////////////////        }
////////////////////        return father[x];
////////////////////    }
////////////////////
////////////////////    public static boolean isSameSet(int x, int y) {
////////////////////        return find(x) == find(y);
////////////////////    }
////////////////////
////////////////////    public static void union(int x, int y) {
////////////////////        int fx = find(x);
////////////////////        int fy = find(y);
////////////////////        if (fx != fy) {
////////////////////            father[fy] = fx;
////////////////////        }
////////////////////    }
////////////////////
////////////////////    public static void build(int n) {
////////////////////        for (int i = 1; i <= n; i++) {
////////////////////            father[i] = i;
////////////////////        }
////////////////////    }
////////////////////
////////////////////
////////////////////    public int[] findRedundantConnection(int[][] edges) {
////////////////////        build(edges.length);
////////////////////        int[] ret = new int[2];
////////////////////        for (int i = 0; i < edges.length; i++) {
////////////////////            int[] edge = edges[i];
////////////////////            if (isSameSet(edge[0], edge[1])) {
////////////////////                ret[0] = edge[0];
////////////////////                ret[1] = edge[1];
////////////////////            } else {
////////////////////                union(edge[0], edge[1]);
////////////////////            }
////////////////////        }
////////////////////        return ret;
////////////////////    }
////////////////////
////////////////////
////////////////////    public boolean isPalindrome(String s) {
////////////////////        char[] charArray = s.toCharArray();
////////////////////        int i = 0;
////////////////////        int j = charArray.length - 1;
////////////////////        while (i < j) {
////////////////////            if (isDictOrNum(charArray[i]) && isDictOrNum(charArray[j])) {
////////////////////                if (charArray[i] >= '0' && charArray[i] <= '9' && charArray[j] > '9') {
////////////////////                    return false;
////////////////////                }
////////////////////                if (charArray[j] >= '0' && charArray[j] <= '9' && charArray[i] > '9') {
////////////////////                    return false;
////////////////////                }
////////////////////
////////////////////                if (charArray[i] != charArray[j] && charArray[i] + 32 != charArray[j] && charArray[i] != charArray[j] + 32) {
////////////////////                    return false;
////////////////////                }
////////////////////                i++;
////////////////////                j--;
////////////////////            } else if (!isDictOrNum(charArray[i]) && isDictOrNum(charArray[j])) {
////////////////////                i++;
////////////////////            } else if (isDictOrNum(charArray[i]) && !isDictOrNum(charArray[j])) {
////////////////////                j--;
////////////////////            } else {
////////////////////                i++;
////////////////////                j--;
////////////////////            }
////////////////////        }
////////////////////        return true;
////////////////////    }
////////////////////
////////////////////    private boolean isDictOrNum(char c) {
////////////////////        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
////////////////////    }
////////////////////
////////////////////    public int[] getFinalState(int[] nums, int k, int multiplier) {
////////////////////        TreeMap<Integer, Integer> map = new TreeMap<>();
////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////            map.put(nums[i], i);
////////////////////        }
////////////////////        while (k > 0) {
////////////////////            int min = map.firstKey();
////////////////////            int minIndex = map.get(min);
////////////////////            map.remove(min);
////////////////////            map.put(min * multiplier, minIndex);
////////////////////            k--;
////////////////////        }
////////////////////        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
////////////////////            System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue());
////////////////////        }
////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////            nums[map.get(map.firstKey())] = map.firstKey();
////////////////////            map.remove(map.firstKey());
////////////////////        }
////////////////////        return nums;
////////////////////    }
////////////////////
////////////////////    public int mincostTickets(int[] days, int[] costs) {
////////////////////        int n = days.length;
////////////////////        Arrays.fill(dp, 0, n + 1, Integer.MAX_VALUE);
////////////////////        dp[n] = 0;
////////////////////        for (int i = n - 1; i >= 0; i--) {
////////////////////            for (int k = 0, j = i; k < 3; k++) {
////////////////////                while (j < n && days[i] + duration[k] > days[j]) {
////////////////////                    j++;
////////////////////                }
////////////////////                dp[i] = Math.min(dp[i], costs[k] + dp[j]);
////////////////////            }
////////////////////        }
////////////////////        return dp[0];
////////////////////    }
////////////////////
////////////////////    public int maxTotalReward(int[] rewardValues) {
////////////////////        int tmp = 0;
////////////////////        for (int v : rewardValues) {
////////////////////            tmp = Math.max(tmp, v);
////////////////////        }
////////////////////        for (int v : rewardValues) {
////////////////////            if (v == tmp - 1) {
////////////////////                return tmp * 2 - 1;
////////////////////            }
////////////////////        }
////////////////////        BigInteger dp = BigInteger.ONE;
////////////////////        for (int v : Arrays.stream(rewardValues).distinct().sorted().toArray()) {
////////////////////            BigInteger mask = BigInteger.ONE.shiftLeft(v).subtract(BigInteger.ONE);
////////////////////            dp = dp.or(dp.and(mask).shiftLeft(v));
////////////////////        }
////////////////////        return dp.bitLength() - 1;
////////////////////    }
////////////////////
////////////////////    private int f(int[] days, int[] costs, int i, int[] dp) {
////////////////////        if (i == days.length) return 0;
////////////////////        if (dp[i] != Integer.MAX_VALUE) {
////////////////////            return dp[i];
////////////////////        }
////////////////////        int ans = Integer.MAX_VALUE;
////////////////////        for (int k = 0, j = i; k < 3; k++) {
////////////////////            while (j < days.length && days[i] + duration[k] > days[j]) {
////////////////////                j++;
////////////////////            }
////////////////////            ans = Math.min(ans, costs[k] + f(days, costs, j, dp));
////////////////////        }
////////////////////        dp[i] = ans;
////////////////////        return ans;
////////////////////    }
////////////////////
////////////////////    public String addBinary(String a, String b) {
////////////////////        StringBuilder sb = new StringBuilder();
////////////////////        int i = a.length() - 1, j = b.length() - 1, carry = 0;
////////////////////        for (; i >= 0 || j >= 0; i--, j--) {
////////////////////            if (i >= 0) carry += a.charAt(i) - '0';
////////////////////            if (j >= 0) carry += b.charAt(j) - '0';
////////////////////            sb.append(carry % 2);
////////////////////            carry /= 2;
////////////////////        }
////////////////////        if (carry > 0) sb.append('1');
////////////////////        return sb.reverse().toString();
////////////////////    }
////////////////////
////////////////////    public long countCompleteDayPairs(int[] hours) {
////////////////////        int[] cnt = new int[24];
////////////////////        long ans = 0;
////////////////////        for (int i = 0; i < hours.length; i++) {
////////////////////            ans += cnt[(24 - hours[i] % 24) % 24];
////////////////////            cnt[hours[i] % 24]++;
////////////////////        }
////////////////////        return ans;
////////////////////    }
////////////////////
////////////////////    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
////////////////////        int[] cur = new int[n];
////////////////////        Arrays.fill(cur, Integer.MAX_VALUE);
////////////////////        cur[src] = 0;
////////////////////        for (int i = 0; i <= k; i++) {
////////////////////            int[] next = Arrays.copyOf(cur, n);
////////////////////            for (int[] edge : flights) {
////////////////////                if (cur[edge[0]] != Integer.MAX_VALUE) {
////////////////////                    next[edge[0]] = Math.min(next[edge[1]], cur[edge[0]] + edge[2]);
////////////////////                }
////////////////////            }
////////////////////            cur = next;
////////////////////        }
////////////////////        return cur[dst] == Integer.MAX_VALUE ? -1 : cur[dst];
////////////////////    }
//////////////////////
//////////////////////    public static int MAX_N = 101;
//////////////////////
//////////////////////    public static int MAX_M = 6001;
//////////////////////
//////////////////////    public static int[] head = new int[MAX_N];
//////////////////////
//////////////////////    public static int[] next = new int[MAX_M];
//////////////////////
//////////////////////    public static int[] to = new int[MAX_M];
//////////////////////
//////////////////////    public static int[] weight = new int[MAX_M];
//////////////////////
//////////////////////    public static int cnt;
//////////////////////
//////////////////////    public static int[] moved = new int[]{-1, 0, 1, 0, -1};
//////////////////////
//////////////////////    public static void addEdge(int u, int v, int w) {
//////////////////////        next[cnt] = head[u];
//////////////////////        to[cnt] = v;
//////////////////////        weight[cnt] = w;
//////////////////////        head[u] = cnt++;
//////////////////////    }
//////////////////////
//////////////////////    public static void build(int n) {
//////////////////////        cnt = 1;
//////////////////////        Arrays.fill(head, 0, n + 1, 0);
//////////////////////    }
//////////////////////
//////////////////////    public int electricCarPlan(int[][] paths, int cnt, int start, int end, int[] charge) {
//////////////////////        int n = paths.length;
//////////////////////        build(n);
//////////////////////        for (int[] path : paths) {
//////////////////////            addEdge(path[0], path[1], path[2]);
//////////////////////            addEdge(path[1], path[0], path[2]);
//////////////////////        }
//////////////////////        int[][] distance = new int[n][cnt + 1];
//////////////////////        for (int i = 0; i < n; i++) {
//////////////////////            for (int j = 0; j < cnt + 1; j++) {
//////////////////////                distance[i][j] = Integer.MAX_VALUE;
//////////////////////            }
//////////////////////        }
//////////////////////        distance[start][0] = 0;
//////////////////////        boolean[][] visited = new boolean[n][cnt + 1];
//////////////////////        PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[2] - b[2]);
//////////////////////        heap.add(new int[]{start, 0, 0});
//////////////////////        while (!heap.isEmpty()) {
//////////////////////            int[] record = heap.poll();
//////////////////////            int cur = record[0];
//////////////////////            int power = record[1];
//////////////////////            int cost = record[2];
//////////////////////            if (visited[cur][power]) {
//////////////////////                continue;
//////////////////////            }
//////////////////////            if (cur == end) {
//////////////////////                return cost;
//////////////////////            }
//////////////////////            visited[cur][power] = true;
//////////////////////            if (power < cnt) {
//////////////////////                if (!visited[cur][power + 1] && cost + charge[cur] < distance[cur][power + 1]) {
//////////////////////                    distance[cur][power + 1] = cost + charge[cur];
//////////////////////                    heap.add(new int[]{cur, power + 1, cost + charge[cur]});
//////////////////////                }
//////////////////////            }
//////////////////////            for (int ei = head[cur]; ei > 0; ei = next[ei]) {
//////////////////////                int nextCity = to[ei];
//////////////////////                int restPower = power - weight[ei];
//////////////////////                int nextCost = cost + weight[ei];
//////////////////////                if (restPower >= 0 && !visited[nextCity][restPower] && nextCost < distance[nextCity][restPower]) {
//////////////////////                    distance[nextCity][restPower] = nextCost;
//////////////////////                    heap.add(new int[]{nextCity, restPower, nextCost});
//////////////////////                }
//////////////////////            }
//////////////////////        }
//////////////////////        return -1;
//////////////////////    }
//////////////////////
//////////////////////    public int swimInWater(int[][] grid) {
//////////////////////        int n = grid.length;
//////////////////////        int m = grid[0].length;
//////////////////////        int[][] distance = new int[n][m];
//////////////////////        for (int i = 0; i < n; i++) {
//////////////////////            for (int j = 0; j < m; j++) {
//////////////////////                distance[i][j] = Integer.MAX_VALUE;
//////////////////////            }
//////////////////////        }
//////////////////////        distance[0][0] = grid[0][0];
//////////////////////        boolean[][] visited = new boolean[n][m];
//////////////////////        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
//////////////////////        pq.add(new int[]{0, 0, 0});
//////////////////////        while (!pq.isEmpty()) {
//////////////////////            int[] record = pq.poll();
//////////////////////            int x = record[0];
//////////////////////            int y = record[1];
//////////////////////            int w = record[2];
//////////////////////            if (visited[x][y]) {
//////////////////////                continue;
//////////////////////            }
//////////////////////            if (x == n - 1 && y == m - 1) {
//////////////////////                return w;
//////////////////////            }
//////////////////////            visited[x][y] = true;
//////////////////////            for (int i = 0; i < 4; i++) {
//////////////////////                int nx = x + moved[i];
//////////////////////                int ny = y + moved[i + 1];
//////////////////////                if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
//////////////////////                    int nw = Math.max(w, grid[nx][ny]);
//////////////////////                    if (nw < distance[nx][ny]) {
//////////////////////                        distance[nx][ny] = nw;
//////////////////////                        pq.add(new int[]{nx, ny, nw});
//////////////////////                    }
//////////////////////                }
//////////////////////            }
//////////////////////        }
//////////////////////        return -1;
//////////////////////    }
//////////////////////
//////////////////////    public int minimumEffortPath(int[][] heights) {
//////////////////////        int n = heights.length;
//////////////////////        int m = heights[0].length;
//////////////////////        int[][] distance = new int[n][m];
//////////////////////        for (int i = 0; i < n; i++) {
//////////////////////            for (int j = 0; j < m; j++) {
//////////////////////                distance[i][j] = Integer.MAX_VALUE;
//////////////////////            }
//////////////////////        }
//////////////////////        distance[0][0] = 0;
//////////////////////        boolean[][] visited = new boolean[n][m];
//////////////////////        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
//////////////////////        pq.add(new int[]{0, 0, 0});
//////////////////////        while (!pq.isEmpty()) {
//////////////////////            int[] record = pq.poll();
//////////////////////            int x = record[0];
//////////////////////            int y = record[1];
//////////////////////            int w = record[2];
//////////////////////            if (visited[x][y]) {
//////////////////////                continue;
//////////////////////            }
//////////////////////            if (x == n - 1 && y == m - 1) {
//////////////////////                return w;
//////////////////////            }
//////////////////////            visited[x][y] = true;
//////////////////////            for (int i = 0; i < 4; i++) {
//////////////////////                int nx = x + moved[i];
//////////////////////                int ny = y + moved[i + 1];
//////////////////////                if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
//////////////////////                    int nw = Math.max(w, Math.abs(heights[x][y] - heights[nx][ny]));
//////////////////////                    if (nw < distance[nx][ny]) {
//////////////////////                        distance[nx][ny] = nw;
//////////////////////                        pq.add(new int[]{nx, ny, nw});
//////////////////////                    }
//////////////////////                }
//////////////////////            }
//////////////////////        }
//////////////////////        return -1;
//////////////////////    }
//////////////////////
//////////////////////    public static void build(int n) {
//////////////////////        cnt = 1;
//////////////////////        Arrays.fill(head, 0, n + 1, 0);
//////////////////////        Arrays.fill(next, 0, n + 1, 0);
//////////////////////        Arrays.fill(to, 0, n + 1, 0);
//////////////////////        Arrays.fill(weight, 0, n + 1, 0);
//////////////////////    }
//////////////////////
//////////////////////    public int countCompleteDayPairs(int[] hours) {
//////////////////////        int count = 0;
//////////////////////        int hash[] = new int[24];
//////////////////////        for (int i = 0; i < hours.length; i++) {
//////////////////////            count += (hash[24 - hours[i] % 24]);
//////////////////////            hash[hours[i] % 24]++;
//////////////////////        }
//////////////////////        return count;
//////////////////////    }
//////////////////////
//////////////////////
//////////////////////    public int networkDelayTime(int[][] times, int n, int k) {
//////////////////////        build(n);
//////////////////////        for (int i = 0; i < times.length; i++) {
//////////////////////            int u = times[i][0];
//////////////////////            int v = times[i][1];
//////////////////////            int w = times[i][2];
//////////////////////            addEdge(u, v, w);
//////////////////////        }
//////////////////////        slove(k);
//////////////////////        int ans = Integer.MIN_VALUE;
//////////////////////        for (int i = 1; i <= n; i++) {
//////////////////////            if (distance[i] == Integer.MAX_VALUE) {
//////////////////////                return -1;
//////////////////////            }
//////////////////////            ans = Math.max(ans, distance[i]);
//////////////////////        }
//////////////////////        return ans;
//////////////////////    }
//////////////////////
//////////////////////    public int networkDelayTime(int[][] times, int n, int k) {
//////////////////////        build(n);
//////////////////////        for (int i = 0; i < times.length; i++) {
//////////////////////            int u = times[i][0];
//////////////////////            int v = times[i][1];
//////////////////////            int w = times[i][2];
//////////////////////            addEdge(u, v, w);
//////////////////////        }
//////////////////////        int[] distance = new int[n + 1];
//////////////////////        Arrays.fill(distance, Integer.MAX_VALUE);
//////////////////////        distance[k] = 0;
//////////////////////        boolean[] visited = new boolean[n + 1];
//////////////////////        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);
//////////////////////        pq.add(new int[]{k, 0});
//////////////////////        while (!pq.isEmpty()) {
//////////////////////            int[] record = pq.poll();
//////////////////////            int u = record[0];
//////////////////////            if (visited[u]) {
//////////////////////                continue;
//////////////////////            }
//////////////////////            visited[u] = true;
//////////////////////            for (int ei = head[u]; ei > 0; ei = next[ei]) {
//////////////////////                int v = to[ei];
//////////////////////                int w = weight[ei];
//////////////////////                if (distance[u] + w < distance[v]) {
//////////////////////                    distance[v] = distance[u] + w;
//////////////////////                    pq.add(new int[]{v, distance[u] + w});
//////////////////////                }
//////////////////////            }
//////////////////////        }
//////////////////////        int ans = Integer.MIN_VALUE;
//////////////////////        for (int i = 1; i <= n; i++) {
//////////////////////            if (distance[i] == Integer.MAX_VALUE) {
//////////////////////                return -1;
//////////////////////            }
//////////////////////            ans = Math.max(ans, distance[i]);
//////////////////////        }
//////////////////////        return ans;
//////////////////////    }
//////////////////////
//////////////////////
//////////////////////    public static int MAXN = 1 << 20;
//////////////////////
//////////////////////    public static int[] lsum = new int[MAXN];
//////////////////////
//////////////////////    public static int[] rsum = new int[MAXN];
//////////////////////
//////////////////////    public static int fill;
//////////////////////
//////////////////////    public static int minAbsDifference(int[] nums, int goal) {
//////////////////////        int n = nums.length;
//////////////////////        long min = 0;
//////////////////////        long max = 0;
//////////////////////        for (int i = 0; i < n; i++) {
//////////////////////            if (nums[i] >= 0) {
//////////////////////                max += nums[i];
//////////////////////            } else {
//////////////////////                min += nums[i];
//////////////////////            }
//////////////////////        }
//////////////////////        if (max < goal) {
//////////////////////            return (int) Math.abs(max - goal);
//////////////////////        }
//////////////////////        if (min > goal) {
//////////////////////            return (int) Math.abs(min - goal);
//////////////////////        }
//////////////////////        // 原始数组排序，为了后面递归的时候，还能剪枝
//////////////////////        // 常数优化
//////////////////////        Arrays.sort(nums);
//////////////////////        fill = 0;
//////////////////////        collect(nums, 0, n >> 1, 0, lsum);
//////////////////////        int lsize = fill;
//////////////////////        fill = 0;
//////////////////////        collect(nums, n >> 1, n, 0, rsum);
//////////////////////        int rsize = fill;
//////////////////////        Arrays.sort(lsum, 0, lsize);
//////////////////////        Arrays.sort(rsum, 0, rsize);
//////////////////////        int ans = Math.abs(goal);
//////////////////////        for (int i = 0, j = rsize - 1; i < lsize; i++) {
//////////////////////            while (j > 0 && Math.abs(goal - lsum[i] - rsum[j - 1]) <= Math.abs(goal - lsum[i] - rsum[j])) {
//////////////////////                j--;
//////////////////////            }
//////////////////////            ans = Math.min(ans, Math.abs(goal - lsum[i] - rsum[j]));
//////////////////////        }
//////////////////////        return ans;
//////////////////////    }
//////////////////////
//////////////////////    public static void collect(int[] nums, int i, int e, int s, int[] sum) {
//////////////////////        if (i == e) {
//////////////////////            sum[fill++] = s;
//////////////////////        } else {
//////////////////////            // nums[i.....]这一组，相同的数字有几个
//////////////////////            int j = i + 1;
//////////////////////            while (j < e && nums[j] == nums[i]) {
//////////////////////                j++;
//////////////////////            }
//////////////////////            // nums[ 1 1 1 1 1 2....
//////////////////////            //       i         j
//////////////////////            for (int k = 0; k <= j - i; k++) {
//////////////////////                // k = 0个
//////////////////////                // k = 1个
//////////////////////                // k = 2个
//////////////////////                collect(nums, j, e, s + k * nums[i], sum);
//////////////////////            }
//////////////////////        }
//////////////////////    }
////////////////////////
////////////////////////
////////////////////////
////////////////////////    public int minAbsDifference(int[] nums, int goal) {
////////////////////////
////////////////////////    }
////////////////////////
////////////////////////    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
////////////////////////        HashSet<String> dict = new HashSet<>(wordList);
////////////////////////        if (!dict.contains(endWord)) {
////////////////////////            return 0;
////////////////////////        }
////////////////////////        HashSet<String> smallLevel = new HashSet<>();
////////////////////////        HashSet<String> nextLevel = new HashSet<>();
////////////////////////        HashSet<String> bigLevel = new HashSet<>();
////////////////////////        smallLevel.add(beginWord);
////////////////////////        bigLevel.add(endWord);
////////////////////////        for (int len = 2; !smallLevel.isEmpty(); len++) {
////////////////////////            for (String w : smallLevel) {
////////////////////////                char[] word = w.toCharArray();
////////////////////////                for (int j = 0; j < word.length; j++) {
////////////////////////                    char old = word[j];
////////////////////////                    for (char change = 'a'; change <= 'z'; change++) {
////////////////////////                        if (change != old) {
////////////////////////                            word[j] = change;
////////////////////////                            String next = String.valueOf(word);
////////////////////////                            if (bigLevel.contains(next)) {
////////////////////////                                return len;
////////////////////////                            }
////////////////////////                            if (dict.contains(next)) {
////////////////////////                                dict.remove(next);
////////////////////////                                nextLevel.add(next);
////////////////////////                            }
////////////////////////                        }
////////////////////////                    }
////////////////////////                    word[j] = old;
////////////////////////                }
////////////////////////            }
////////////////////////            if (nextLevel.size() <= bigLevel.size()) {
////////////////////////                HashSet<String> tmp = smallLevel;
////////////////////////                smallLevel = nextLevel;
////////////////////////                nextLevel = tmp;
////////////////////////            } else {
////////////////////////                HashSet<String> tmp = smallLevel;
////////////////////////                smallLevel = bigLevel;
////////////////////////                bigLevel = nextLevel;
////////////////////////                nextLevel = tmp;
////////////////////////            }
////////////////////////            nextLevel.clear();
////////////////////////        }
////////////////////////        return 0;
////////////////////////    }
////////////////////////
////////////////////////    public static HashSet<String> dict;
////////////////////////
////////////////////////    public static HashSet<String> curLevel = new HashSet<>();
////////////////////////
////////////////////////    public static HashSet<String> nextLevel = new HashSet<>();
////////////////////////
////////////////////////    public static HashMap<String, ArrayList<String>> graph = new HashMap<>();
////////////////////////
////////////////////////    public static LinkedList<String> path = new LinkedList<>();
////////////////////////
////////////////////////    public static List<List<String>> ans = new ArrayList<>();
////////////////////////
////////////////////////    public static void build(List<String> wordList) {
////////////////////////        dict = new HashSet<>(wordList);
////////////////////////        graph.clear();
////////////////////////        ans.clear();
////////////////////////        curLevel.clear();
////////////////////////        nextLevel.clear();
////////////////////////    }
////////////////////////
////////////////////////    public static List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
////////////////////////        build(wordList);
////////////////////////        if (!dict.contains(endWord)) {
////////////////////////            return ans;
////////////////////////        }
////////////////////////        if (bfs(beginWord, endWord)) {
////////////////////////            dfs(endWord, beginWord);
////////////////////////        }
////////////////////////        return ans;
////////////////////////    }
////////////////////////
////////////////////////    public static boolean bfs(String begin, String end) {
////////////////////////        boolean find = false;
////////////////////////        curLevel.add(begin);
////////////////////////        while (!curLevel.isEmpty()) {
////////////////////////            dict.removeAll(curLevel);
////////////////////////            for (String word : curLevel) {
////////////////////////                char[] w = word.toCharArray();
////////////////////////                for (int i = 0; i < w.length; i++) {
////////////////////////                    char old = w[i];
////////////////////////                    for (char ch = 'a'; ch <= 'z'; ch++) {
////////////////////////                        w[i] = ch;
////////////////////////                        String str = String.valueOf(w);
////////////////////////                        if (dict.contains(str) && !str.equals(word)) {
////////////////////////                            if (str.equals(end)) {
////////////////////////                                find = true;
////////////////////////                            }
////////////////////////                            graph.putIfAbsent(str, new ArrayList<>());
////////////////////////                            graph.get(str).add(word);
////////////////////////                            nextLevel.add(str);
////////////////////////                        }
////////////////////////                    }
////////////////////////                    w[i] = old;
////////////////////////                }
////////////////////////            }
////////////////////////            if (find) {
////////////////////////                return true;
////////////////////////            } else {
////////////////////////                HashSet<String> tmp = curLevel;
////////////////////////                curLevel = nextLevel;
////////////////////////                nextLevel = tmp;
////////////////////////                nextLevel.clear();
////////////////////////            }
////////////////////////        }
////////////////////////        return false;
////////////////////////    }
////////////////////////
////////////////////////    public static void dfs(String word, String aim) {
////////////////////////        path.addFirst(word);
////////////////////////        if (word.equals(aim)) {
////////////////////////            ans.add(new ArrayList<>(path));
////////////////////////        } else if (graph.containsKey(word)) {
////////////////////////            for (String next : graph.get(word)) {
////////////////////////                dfs(next, aim);
////////////////////////            }
////////////////////////        }
////////////////////////        path.removeFirst();
////////////////////////    }
////////////////////////
////////////////////////
////////////////////////    public int trapRainWater(int[][] heightMap) {
////////////////////////        int[] move = new int[]{-1, 0, 1, 0, -1};
////////////////////////        int n = heightMap.length;
////////////////////////        int m = heightMap[0].length;
////////////////////////        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
////////////////////////        boolean[][] visited = new boolean[n][m];
////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////                if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
////////////////////////                    visited[i][j] = true;
////////////////////////                    pq.add(new int[]{i, j, heightMap[i][j]});
////////////////////////                } else {
////////////////////////                    visited[i][j] = false;
////////////////////////                }
////////////////////////            }
////////////////////////        }
////////////////////////        int ans = 0;
////////////////////////        while (!pq.isEmpty()) {
////////////////////////            int[] record = pq.poll();
////////////////////////            int x = record[0];
////////////////////////            int y = record[1];
////////////////////////            int w = record[2];
////////////////////////            ans += w - heightMap[x][y];
////////////////////////            for (int i = 0, nx, ny, h; i < 4; i++) {
////////////////////////                nx = x + move[i];
////////////////////////                ny = y + move[i + 1];
////////////////////////                if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
////////////////////////                    visited[nx][ny] = true;
////////////////////////                    pq.add(new int[]{nx, ny, Math.max(heightMap[nx][ny], w)});
////////////////////////                }
////////////////////////            }
////////////////////////        }
////////////////////////        return ans;
////////////////////////    }
////////////////////////
////////////////////////    public static int[][] moved = new int[][]{{}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
////////////////////////
////////////////////////    public static int[][] distance;
////////////////////////    public static ArrayDeque<int[]> deque = new ArrayDeque<>();
////////////////////////
////////////////////////    public static void build(int n, int m) {
////////////////////////        distance = new int[n][m];
////////////////////////        deque.clear();
////////////////////////    }
////////////////////////
////////////////////////    public int minCost(int[][] grid) {
////////////////////////        int n = grid.length;
////////////////////////        int m = grid[0].length;
////////////////////////        build(n, m);
////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////                distance[i][j] = Integer.MAX_VALUE;
////////////////////////            }
////////////////////////        }
////////////////////////        deque.addFirst(new int[]{0, 0});
////////////////////////        distance[0][0] = 0;
////////////////////////        while (!deque.isEmpty()) {
////////////////////////            int[] record = deque.pollFirst();
////////////////////////            int x = record[0];
////////////////////////            int y = record[1];
////////////////////////            if (x == n - 1 && y == m - 1) {
////////////////////////                return distance[x][y];
////////////////////////            }
////////////////////////            for (int i = 1; i <= 4; i++) {
////////////////////////                int nx = x + moved[i][0];
////////////////////////                int ny = y + moved[i][1];
////////////////////////                int weight = grid[x][y] == i ? 0 : 1;
////////////////////////                if (nx >= 0 && nx < n && ny >= 0 && ny < m && distance[x][y] + weight < distance[nx][ny]) {
////////////////////////                    distance[nx][ny] = distance[x][y] + weight;
////////////////////////                    if (weight == 0) {
////////////////////////                        deque.addFirst(new int[]{nx, ny});
////////////////////////                    } else {
////////////////////////                        deque.addLast(new int[]{nx, ny});
////////////////////////                    }
////////////////////////                }
////////////////////////            }
////////////////////////        }
////////////////////////        return -1;
////////////////////////    }
////////////////////////
//////////////////////////
//////////////////////////    public static int MAX_N = 401;
//////////////////////////
//////////////////////////
//////////////////////////    public static String[] que = new String[MAX_N];
//////////////////////////
//////////////////////////    public static int l, r;
//////////////////////////    public static ArrayList<ArrayList<String>> graph = new ArrayList<>();
//////////////////////////
//////////////////////////    static {
//////////////////////////        for (int i = 0; i < 26; i++) {
//////////////////////////            graph.add(new ArrayList<>());
//////////////////////////        }
//////////////////////////    }
//////////////////////////
//////////////////////////    public static HashSet<String> visited = new HashSet<>();
//////////////////////////
//////////////////////////    public static int[][] distance;
//////////////////////////
//////////////////////////    public static int[] move = new int[]{-1, 0, 1, 0, -1};
//////////////////////////
//////////////////////////    public static ArrayDeque<int[]> deque;
//////////////////////////
//////////////////////////    public static void build(int n, int m) {
//////////////////////////        distance = new int[n][m];
//////////////////////////        deque.clear();
//////////////////////////    }
//////////////////////////
//////////////////////////    class MedianFinder {
//////////////////////////
//////////////////////////        public int MAX_N = 50001;
//////////////////////////        public int[] maxHeap = new int[MAX_N];
//////////////////////////
//////////////////////////        public int maxSize;
//////////////////////////
//////////////////////////        public int[] minHeap = new int[MAX_N];
//////////////////////////
//////////////////////////        public int minSize;
//////////////////////////
//////////////////////////        public void maxHeapPush(int num) {
//////////////////////////            int i = maxSize;
//////////////////////////            maxHeap[maxSize++] = num;
//////////////////////////            while (maxHeap[i] > maxHeap[(i - 1) / 2]) {
//////////////////////////                swap(maxHeap, i, (i - 1) / 2);
//////////////////////////                i = (i - 1) / 2;
//////////////////////////            }
//////////////////////////        }
//////////////////////////
//////////////////////////        public int maxHeapPop() {
//////////////////////////            int ans = maxHeap[0];
//////////////////////////            maxHeap[0] = maxHeap[--maxSize];
//////////////////////////            int i = 0;
//////////////////////////            int l = 2 * i + 1;
//////////////////////////            while (l < maxSize) {
//////////////////////////                int best = l + 1 < maxSize && maxHeap[l + 1] > maxHeap[l] ? l + 1 : l;
//////////////////////////                best = maxHeap[best] > maxHeap[i] ? best : i;
//////////////////////////                if (best == i) {
//////////////////////////                    break;
//////////////////////////                }
//////////////////////////                swap(maxHeap, i, best);
//////////////////////////                i = best;
//////////////////////////                l = 2 * i + 1;
//////////////////////////            }
//////////////////////////            return ans;
//////////////////////////        }
//////////////////////////
//////////////////////////        public boolean maxIsEmpty() {
//////////////////////////            return maxSize == 0;
//////////////////////////        }
//////////////////////////
//////////////////////////        public boolean minIsEmpty() {
//////////////////////////            return minSize == 0;
//////////////////////////        }
//////////////////////////
//////////////////////////        public void minHeapPush(int num) {
//////////////////////////            int i = minSize;
//////////////////////////            minHeap[minSize++] = num;
//////////////////////////            while (minHeap[i] < minHeap[(i - 1) / 2]) {
//////////////////////////                swap(minHeap, i, (i - 1) / 2);
//////////////////////////                i = (i - 1) / 2;
//////////////////////////            }
//////////////////////////        }
//////////////////////////
//////////////////////////        public int minHeapPeek() {
//////////////////////////            return minHeap[0];
//////////////////////////        }
//////////////////////////
//////////////////////////        public int maxHeapPeek() {
//////////////////////////            return maxHeap[0];
//////////////////////////        }
//////////////////////////
//////////////////////////        public int minHeapPop() {
//////////////////////////            int ans = minHeap[0];
//////////////////////////            minHeap[0] = minHeap[--minSize];
//////////////////////////            int i = 0;
//////////////////////////            int l = 2 * i + 1;
//////////////////////////            while (l < minSize) {
//////////////////////////                int best = l + 1 < minSize && minHeap[l + 1] < minHeap[l] ? l + 1 : l;
//////////////////////////                best = minHeap[best] < minHeap[i] ? best : i;
//////////////////////////                if (best == i) {
//////////////////////////                    break;
//////////////////////////                }
//////////////////////////                swap(minHeap, i, best);
//////////////////////////                i = best;
//////////////////////////                l = 2 * i + 1;
//////////////////////////            }
//////////////////////////            return ans;
//////////////////////////        }
//////////////////////////
//////////////////////////        public void swap(int[] arr, int i, int j) {
//////////////////////////            int temp = arr[i];
//////////////////////////            arr[i] = arr[j];
//////////////////////////            arr[j] = temp;
//////////////////////////        }
//////////////////////////
//////////////////////////
//////////////////////////        public MedianFinder() {
//////////////////////////        maxSize = 0;
//////////////////////////        minSize = 0;
//////////////////////////        }
//////////////////////////
//////////////////////////        public void addNum(int num) {
//////////////////////////            if (maxIsEmpty() || num <= maxHeapPeek()) {
//////////////////////////                maxHeapPush(num);
//////////////////////////            } else {
//////////////////////////                minHeapPush(num);
//////////////////////////            }
//////////////////////////            balance();
//////////////////////////        }
//////////////////////////
//////////////////////////        private void balance() {
//////////////////////////            if (Math.abs(minSize - maxSize) == 2) {
//////////////////////////                if (minSize > maxSize) {
//////////////////////////                    maxHeapPush(minHeapPop());
//////////////////////////                } else {
//////////////////////////                    minHeapPush(maxHeapPop());
//////////////////////////                }
//////////////////////////            }
//////////////////////////        }
//////////////////////////
//////////////////////////        public double findMedian() {
//////////////////////////            if (maxSize == minSize) {
//////////////////////////                double f = (maxHeapPeek() + minHeapPeek()) / 2.0;
//////////////////////////                BigDecimal bg = new BigDecimal(f);
//////////////////////////                return bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
//////////////////////////            }
//////////////////////////            return maxSize > minSize ? maxHeapPeek() : minHeapPeek();
//////////////////////////        }
//////////////////////////    }
//////////////////////////
//////////////////////////    public static int MAX_N = 100001;
//////////////////////////
//////////////////////////    public static int[] heap = new int[MAX_N];
//////////////////////////
//////////////////////////    public static int heapSize;
//////////////////////////
//////////////////////////    public static void clear(int n) {
//////////////////////////        heapSize = 0;
//////////////////////////        Arrays.fill(heap, 0, n + 1, 0);
//////////////////////////    }
//////////////////////////
//////////////////////////    public static void push(int num) {
//////////////////////////        int i = heapSize;
//////////////////////////        heap[heapSize++] = num;
//////////////////////////        while (heap[i] > heap[(i - 1) / 2]) {
//////////////////////////            swap(i, (i - 1) / 2);
//////////////////////////            i = (i - 1) / 2;
//////////////////////////        }
//////////////////////////    }
//////////////////////////
//////////////////////////    public static int pop() {
//////////////////////////        int ans = heap[0];
//////////////////////////        heap[0] = heap[--heapSize];
//////////////////////////        int i = 0;
//////////////////////////        int l = 2 * i + 1;
//////////////////////////        while (l < heapSize) {
//////////////////////////            int best = l + 1 < heapSize && heap[l + 1] > heap[l] ? l + 1 : l;
//////////////////////////            best = heap[best] > heap[i] ? best : i;
//////////////////////////            if (best == i) {
//////////////////////////                break;
//////////////////////////            }
//////////////////////////            swap(i, best);
//////////////////////////            i = best;
//////////////////////////            l = 2 * i + 1;
//////////////////////////        }
//////////////////////////        return ans;
//////////////////////////    }
//////////////////////////
//////////////////////////    public static void swap(int i, int j) {
//////////////////////////        int temp = heap[i];
//////////////////////////        heap[i] = heap[j];
//////////////////////////        heap[j] = temp;
//////////////////////////    }
//////////////////////////
//////////////////////////    public int findKthLargest(int[] nums, int k) {
//////////////////////////        int n = nums.length;
//////////////////////////        clear(n);
//////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////            push(nums[i]);
//////////////////////////        }
//////////////////////////        for (int i = 0; i < k - 1; i++) {
//////////////////////////            pop();
//////////////////////////        }
//////////////////////////        return pop();
//////////////////////////    }
//////////////////////////
//////////////////////////    public int smallestRangeII(int[] nums, int k) {
//////////////////////////        Arrays.sort(nums);
//////////////////////////        int n = nums.length;
//////////////////////////        int maxDistance = nums[n - 1] - nums[0];
//////////////////////////        int maxVal = 0;
//////////////////////////        int minVal = 0;
//////////////////////////        for (int i = 0; i < n - 1; ++i) {
//////////////////////////            maxVal = Math.max(nums[i] + k, nums[n - 1] - k);
//////////////////////////            minVal = Math.min(nums[0] + k, nums[i + 1] - k);
//////////////////////////            maxDistance = Math.min(maxDistance, maxVal - minVal);
//////////////////////////        }
//////////////////////////        return maxDistance;
//////////////////////////    }
//////////////////////////
//////////////////////////    public static int minimumObstacles(int[][] grid) {
//////////////////////////        int n = grid.length;
//////////////////////////        int m = grid[0].length;
//////////////////////////        clear(n, m);
//////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////            for (int j = 0; j < m; j++) {
//////////////////////////                distance[i][j] = Integer.MAX_VALUE;
//////////////////////////            }
//////////////////////////        }
//////////////////////////        deque.addFirst(new int[]{0, 0});
//////////////////////////        distance[0][0] = 0;
//////////////////////////        while (!deque.isEmpty()) {
//////////////////////////            int[] point = deque.pollFirst();
//////////////////////////            int x = point[0];
//////////////////////////            int y = point[1];
//////////////////////////            if (x == n - 1 && y == m - 1) {
//////////////////////////                return distance[x][y];
//////////////////////////            }
//////////////////////////            for (int i = 0; i < 4; i++) {
//////////////////////////                int nx = x + move[i];
//////////////////////////                int ny = y + move[i + 1];
//////////////////////////                if (nx >= 0 && nx < n && ny >= 0 && ny < m &&
//////////////////////////                        distance[x][y] + grid[nx][ny] < distance[nx][ny]) {
//////////////////////////                    distance[nx][ny] = distance[x][y] + grid[nx][ny];
//////////////////////////                    if (grid[nx][ny] == 0) {
//////////////////////////                        deque.addFirst(new int[]{nx, ny});
//////////////////////////                    } else {
//////////////////////////                        deque.addLast(new int[]{nx, ny});
//////////////////////////                    }
//////////////////////////                }
//////////////////////////            }
//////////////////////////        }
//////////////////////////        return -1;
//////////////////////////    }
//////////////////////////
//////////////////////////    public static String mySort(String str) {
//////////////////////////        char[] chars = str.toCharArray();
//////////////////////////        Arrays.sort(chars);
//////////////////////////        return String.valueOf(chars);
//////////////////////////    }
//////////////////////////
//////////////////////////    public static String next(String target, String str) {
//////////////////////////        StringBuilder builder = new StringBuilder();
//////////////////////////        for (int i = 0, j = 0; i < target.length(); ) {
//////////////////////////            if (j == str.length()) {
//////////////////////////                builder.append(target.charAt(i++));
//////////////////////////            } else {
//////////////////////////                if (target.charAt(i) < str.charAt(j)) {
//////////////////////////                    builder.append(target.charAt(i++));
//////////////////////////                } else if (target.charAt(i) > str.charAt(j)) {
//////////////////////////                    j++;
//////////////////////////                } else {
//////////////////////////                    i++;
//////////////////////////                    j++;
//////////////////////////                }
//////////////////////////            }
//////////////////////////        }
//////////////////////////        return builder.toString();
//////////////////////////    }
//////////////////////////
//////////////////////////    public int minStickers(String[] stickers, String target) {
//////////////////////////        for (int i = 0; i < 26; i++) {
//////////////////////////            graph.get(i).clear();
//////////////////////////        }
//////////////////////////        visited.clear();
//////////////////////////        l = r = 0;
//////////////////////////        for (String str : stickers) {
//////////////////////////            str = mySort(str);
//////////////////////////            for (int i = 0; i < str.length(); i++) {
//////////////////////////                if (i == 0 || str.charAt(i) != str.charAt(i - 1)) {
//////////////////////////                    graph.get(str.charAt(i) - 'a').add(str);
//////////////////////////                }
//////////////////////////            }
//////////////////////////        }
//////////////////////////        target = mySort(target);
//////////////////////////        visited.add(target);
//////////////////////////        int level = 1;
//////////////////////////        que[r++] = target;
//////////////////////////        while (l < r) {
//////////////////////////            int size = r - l;
//////////////////////////            for (int k = 0; k < size; k++) {
//////////////////////////                String cur = que[l++];
//////////////////////////                for (String s : graph.get(cur.charAt(0) - 'a')) {
//////////////////////////                    String next = next(cur, s);
//////////////////////////                    if (next.equals("")) {
//////////////////////////                        return level;
//////////////////////////                    } else if (!visited.contains(next)) {
//////////////////////////                        visited.add(next);
//////////////////////////                        que[r++] = next;
//////////////////////////                    }
//////////////////////////                }
//////////////////////////            }
//////////////////////////            level++;
//////////////////////////        }
//////////////////////////        return -1;
//////////////////////////    }
//////////////////////////
////////////////////////////    public int MAX_N = 101;
////////////////////////////
////////////////////////////    public int MAX_M = 101;
////////////////////////////
////////////////////////////    public int[][] que = new int[MAX_N * MAX_M][2];
////////////////////////////
////////////////////////////    public boolean[][] visited = new boolean[MAX_N][MAX_M];
////////////////////////////
////////////////////////////    public int l, r;
////////////////////////////
////////////////////////////    public int[] move = new int[]{-1, 0, 1, 0, -1};
////////////////////////////
////////////////////////////    public int maxDistance(int[][] grid) {
////////////////////////////        l = r = 0;
////////////////////////////        int n = grid.length;
////////////////////////////        int m = grid[0].length;
////////////////////////////        int seas = 0;
////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////////                if (grid[i][j] == 1) {
////////////////////////////                    visited[i][j] = true;
////////////////////////////                    que[l][0] = i;
////////////////////////////                    que[l++][1] = j;
////////////////////////////                } else {
////////////////////////////                    seas++;
////////////////////////////                    visited[i][j] = false;
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        if (seas == 0 || seas == n * m) {
////////////////////////////            return -1;
////////////////////////////        }
////////////////////////////        int level = 0;
////////////////////////////        while (l < r) {
////////////////////////////            level++;
////////////////////////////            int size = r - l;
////////////////////////////            for (int k = 0, x, y, nx, ny; k < size; k++) {
////////////////////////////                x = que[l][0];
////////////////////////////                y = que[l++][1];
////////////////////////////                for (int i = 0; i < 4; i++) {
////////////////////////////                    nx = x + move[i];
////////////////////////////                    ny = y + move[i + 1];
////////////////////////////                    if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny]) {
////////////////////////////                        visited[nx][ny] = true;
////////////////////////////                        que[l][0] = nx;
////////////////////////////                        que[l++][1] = ny;
////////////////////////////                    }
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return level - 1;
////////////////////////////    }
//////////////////////////
////////////////////////////
////////////////////////////    public int MAX_N = 100005;
////////////////////////////
////////////////////////////    public int MAX_M = 200005;
////////////////////////////
////////////////////////////    public int[][] questions = new int[MAX_N][4];
////////////////////////////
////////////////////////////    public int[] farther = new int[MAX_N];
////////////////////////////
////////////////////////////    public int cnt;
////////////////////////////
////////////////////////////    public void build(int n){
////////////////////////////        for(int i = 0;i<=n;i++){
////////////////////////////            farther[i] = i;
////////////////////////////        }
////////////////////////////    }
////////////////////////////
////////////////////////////    public int find(int x){
////////////////////////////        if(x != farther[x]){
////////////////////////////            farther[x] = find(farther[x]);
////////////////////////////        }
////////////////////////////        return farther[x];
////////////////////////////    }
////////////////////////////
////////////////////////////    public void union(int x,int y){
////////////////////////////        int fx = find(x);
////////////////////////////        int fy = find(y);
////////////////////////////        if(fx != fy){
////////////////////////////            farther[fx] = fy;
////////////////////////////        }
////////////////////////////    }
////////////////////////////
////////////////////////////    public boolean isSameSet(int x,int y){
////////////////////////////        return find(x)==find(y);
////////////////////////////    }
////////////////////////////
////////////////////////////    public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {
////////////////////////////        Arrays.sort(edgeList, (a, b) -> a[2] - b[2]);
////////////////////////////        int m = edgeList.length;
////////////////////////////        int k = queries.length;
////////////////////////////        for(int i = 0;i<k;i++){
////////////////////////////            questions[i][0] = queries[i][0];
////////////////////////////            questions[i][1] = queries[i][1];
////////////////////////////            questions[i][2] = queries[i][2];
////////////////////////////            questions[i][3] = i;
////////////////////////////        }
////////////////////////////        Arrays.sort(questions,0,k,(a, b) -> a[2] - b[2]);
////////////////////////////        build(n);
////////////////////////////        boolean[] ans = new boolean[k];
////////////////////////////        for(int i = 0,j=0;i<k;i++){
////////////////////////////            for (; j < m && edgeList[j][2] < questions[i][2]; j++) {
////////////////////////////                union(edgeList[j][0], edgeList[j][1]);
////////////////////////////            }
////////////////////////////            ans[questions[i][3]] = isSameSet(queries[i][0], queries[i][1]);
////////////////////////////        }
////////////////////////////        return ans;
////////////////////////////    }
////////////////////////////
////////////////////////////    public int[] head = new int[MAX_N];
////////////////////////////
////////////////////////////    public int[] next = new int[MAX_M];
////////////////////////////
////////////////////////////    public int[] to = new int[MAX_M];
////////////////////////////
////////////////////////////    public int[] indegree = new int[MAX_N];
////////////////////////////
////////////////////////////    public int cnt;
////////////////////////////
////////////////////////////    private void addEdge(int u, int v) {
////////////////////////////        next[cnt] = head[u];
////////////////////////////        to[cnt] = v;
////////////////////////////        head[u] = cnt++;
////////////////////////////    }
////////////////////////////
//////////////////////////////    private void build(int n) {
//////////////////////////////        cnt = 1;
//////////////////////////////        Arrays.fill(head, 0, n + 1, 0);
//////////////////////////////    }
////////////////////////////
////////////////////////////    public int maximumInvitations(int[] favorite) {
////////////////////////////        int n = favorite.length;
////////////////////////////        int[] indegree = new int[n];
////////////////////////////        for (int i = 0; i < favorite.length; i++) {
////////////////////////////            indegree[favorite[i]]++;
////////////////////////////        }
////////////////////////////        int[] que = new int[n];
////////////////////////////        int l = 0;
////////////////////////////        int r = 0;
////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////            if (indegree[i] == 0) {
////////////////////////////                que[r++] = i;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        int[] deep = new int[n];
////////////////////////////        while (l < r) {
////////////////////////////            int cur = que[l++];
////////////////////////////            int next = favorite[cur];
////////////////////////////            deep[next] = Math.max(deep[next], deep[cur] + 1);
////////////////////////////            if (--indegree[next] == 0) {
////////////////////////////                que[r++] = next;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        int sumOfRings = 0;
////////////////////////////        int bigRings = 0;
////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////            if (indegree[i] > 0) {
////////////////////////////                int ringNum = 1;
////////////////////////////                indegree[i] = 0;
////////////////////////////                for (int j = favorite[i]; j != i; j = favorite[j]) {
////////////////////////////                    ringNum++;
////////////////////////////                    indegree[j] = 0;
////////////////////////////                }
////////////////////////////                if (ringNum == 2) {
////////////////////////////                    sumOfRings += 2 + deep[i] + deep[favorite[i]];
////////////////////////////                } else {
////////////////////////////                    bigRings = Math.max(bigRings, ringNum);
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return Math.max(sumOfRings, bigRings);
////////////////////////////    }
////////////////////////////
////////////////////////////    public int minimumTime(int n, int[][] relations, int[] time) {
////////////////////////////        build(n);
////////////////////////////        for (int[] edge : relations) {
////////////////////////////            addEdge(edge[0], edge[1]);
////////////////////////////            indegree[edge[1]]++;
////////////////////////////        }
////////////////////////////        int[] que = new int[n];
////////////////////////////        int l = 0;
////////////////////////////        int r = 0;
////////////////////////////        for (int i = 1; i <= n; i++) {
////////////////////////////            if (indegree[i] == 0) {
////////////////////////////                que[r++] = i;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        int[] cost = new int[n + 1];
////////////////////////////        int ans = 0;
////////////////////////////        while (l < r) {
////////////////////////////            int cur = que[l++];
////////////////////////////            cost[cur] += time[cur - 1];
////////////////////////////            ans = Math.max(ans, cost[cur]);
////////////////////////////            for (int ei = head[cur]; ei > 0; ei = next[ei]) {
////////////////////////////                cost[to[ei]] = Math.max(cost[cur], cost[to[ei]]);
////////////////////////////                if (--indegree[to[ei]] == 0) {
////////////////////////////                    que[r++] = to[ei];
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return ans;
////////////////////////////    }
////////////////////////////
////////////////////////////    public int[] loudAndRich(int[][] richer, int[] quiet) {
////////////////////////////        int n = quiet.length;
////////////////////////////        build(n);
////////////////////////////        for (int[] edge : richer) {
////////////////////////////            addEdge(edge[0], edge[1]);
////////////////////////////            indegree[edge[1]]++;
////////////////////////////        }
////////////////////////////        int[] que = new int[n];
////////////////////////////        int l = 0;
////////////////////////////        int r = 0;
////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////            if (indegree[i] == 0) {
////////////////////////////                que[r++] = i;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        int[] ans = new int[n];
////////////////////////////        for (int i = 0; i < ans.length; i++) {
////////////////////////////            ans[i] = i;
////////////////////////////        }
////////////////////////////        while (l < r) {
////////////////////////////            int cur = que[l++];
////////////////////////////            for (int ei = head[cur]; ei > 0; ei = next[ei]) {
////////////////////////////                if (quiet[ans[cur]] < quiet[ans[to[ei]]]) {
////////////////////////////                    ans[to[ei]] = ans[cur];
////////////////////////////                }
////////////////////////////                if (--indegree[to[ei]] == 0) {
////////////////////////////                    que[r++] = to[ei];
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return ans;
////////////////////////////    }
////////////////////////////
////////////////////////////    class Solution {
////////////////////////////
////////////////////////////        void backtracking(List<List<Integer>> result, ArrayList<Integer> path, int n, int k, int startindex) {
////////////////////////////            if (path.size() == k) {
////////////////////////////                result.add(new ArrayList<>(path));
////////////////////////////                return;
////////////////////////////            }
////////////////////////////            for (int i = startindex; i <= n - (k - path.size()) + 1; i++) {
////////////////////////////                path.add(i);
////////////////////////////                backtracking(result, path, n, k, i + 1);
////////////////////////////                path.remove(path.size() - 1);
////////////////////////////            }
////////////////////////////        }
////////////////////////////
////////////////////////////        public List<List<Integer>> combine(int n, int k) {
////////////////////////////            List<List<Integer>> result = new ArrayList<>();
////////////////////////////            ArrayList<Integer> path = new ArrayList<>();
////////////////////////////            backtracking(result, path, n, k, 1);
////////////////////////////            return result;
////////////////////////////        }
////////////////////////////    }
////////////////////////////
////////////////////////////    ;
////////////////////////////
////////////////////////////    public int[] findOrder(int numCourses, int[][] prerequisites) {
////////////////////////////        cnt = 1;
////////////////////////////        int[] in = new int[numCourses];
////////////////////////////        for (int[] x : prerequisites) {
////////////////////////////            addEdge(x[1], x[0]);
////////////////////////////            in[x[0]]++;
////////////////////////////        }
////////////////////////////        int[] que = new int[numCourses];
////////////////////////////        int l = 0;
////////////////////////////        int r = 0;
////////////////////////////        for (int i = 0; i < numCourses; i++) {
////////////////////////////            if (in[i] == 0) {
////////////////////////////                que[r++] = i;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        int cnt = 0;
////////////////////////////        while (l < r) {
////////////////////////////            int cur = que[l++];
////////////////////////////            cnt++;
////////////////////////////            for (int ei = head[cur]; ei > 0; ei = next[ei]) {
////////////////////////////                if (--in[to[ei]] == 0) {
////////////////////////////                    que[r++] = to[ei];
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return cnt == numCourses ? que : new int[0];
////////////////////////////    }
////////////////////////////
////////////////////////////    public int smallestRangeI(int[] nums, int k) {
////////////////////////////        if (nums.length == 1) {
////////////////////////////            return 0;
////////////////////////////        }
////////////////////////////        int i = 0;
////////////////////////////        int j = nums.length - 1;
////////////////////////////        int min = Integer.MAX_VALUE;
////////////////////////////        Arrays.sort(nums);
////////////////////////////        if (nums[i] + k >= nums[j] - k) {
////////////////////////////            return 0;
////////////////////////////        } else {
////////////////////////////            return nums[j] - k - nums[i] - k;
////////////////////////////        }
////////////////////////////        // return -1;
////////////////////////////    }
////////////////////////////
////////////////////////////    public String alienOrder(String[] words) {
////////////////////////////        cnt = 1;
////////////////////////////        int[] indegree = new int[26];
////////////////////////////        Arrays.fill(indegree, -1);
////////////////////////////        for (String word : words) {
////////////////////////////            for (int i = 0; i < word.length(); i++) {
////////////////////////////                indegree[word.charAt(i) - 'a'] = 0;
////////////////////////////            }
////////////////////////////        }
////////////////////////////
////////////////////////////        for (int i = 0; i < words.length - 1; i++) {
////////////////////////////            String cur = words[i];
////////////////////////////            String next = words[i + 1];
////////////////////////////            int len = Math.min(cur.length(), next.length());
////////////////////////////            int j = 0;
////////////////////////////            for (j = 0; j < len; j++) {
////////////////////////////                if (cur.charAt(j) != next.charAt(j)) {
////////////////////////////                    addEdge(cur.charAt(j) - 'a', next.charAt(j) - 'a');
////////////////////////////                    indegree[next.charAt(j) - 'a']++;
////////////////////////////                    break;
////////////////////////////                }
////////////////////////////            }
////////////////////////////            if (j < cur.length() && j == next.length()) {
////////////////////////////                return "";
////////////////////////////            }
////////////////////////////        }
////////////////////////////
////////////////////////////        int[] que = new int[26];
////////////////////////////        int l = 0;
////////////////////////////        int r = 0;
////////////////////////////        int kinds = 0;
////////////////////////////        for (int i = 0; i < 26; i++) {
////////////////////////////            if (indegree[i] != -1) {
////////////////////////////                kinds++;
////////////////////////////            }
////////////////////////////            if (indegree[i] == 0) {
////////////////////////////                que[r++] = i;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        StringBuilder ans = new StringBuilder();
////////////////////////////        while (l < r) {
////////////////////////////            int cur = que[l++];
////////////////////////////            ans.append((char) (cur + 'a'));
////////////////////////////            for (int ei = head[cur]; ei > 0; ei = next[ei]) {
////////////////////////////                if (--indegree[to[ei]] == 0) {
////////////////////////////                    que[r++] = to[ei];
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return ans.length() == kinds ? ans.toString() : "";
////////////////////////////    }
////////////////////////////
////////////////////////////    public int[] findOrder2(int numCourses, int[][] prerequisites) {
////////////////////////////        ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
////////////////////////////        for (int i = 0; i < numCourses; i++) {
////////////////////////////            graph.add(new ArrayList<>());
////////////////////////////        }
////////////////////////////        int[] in = new int[numCourses];
////////////////////////////        for (int[] x : prerequisites) {
////////////////////////////            graph.get(x[1]).add(x[0]);
////////////////////////////            in[x[0]]++;
////////////////////////////        }
////////////////////////////        int[] que = new int[numCourses];
////////////////////////////        int l = 0;
////////////////////////////        int r = 0;
////////////////////////////        for (int i = 0; i < numCourses; i++) {
////////////////////////////            if (in[i] == 0) {
////////////////////////////                que[r++] = i;
////////////////////////////            }
////////////////////////////        }
////////////////////////////        int cnt = 0;
////////////////////////////        while (l < r) {
////////////////////////////            int cur = que[l++];
////////////////////////////            cnt++;
////////////////////////////            for (int i = 0; i < graph.get(cur).size(); i++) {
////////////////////////////                if (--in[graph.get(cur).get(i)] == 0) {
////////////////////////////                    que[r++] = graph.get(cur).get(i);
////////////////////////////                }
////////////////////////////            }
////////////////////////////        }
////////////////////////////        return cnt == numCourses ? que : new int[0];
////////////////////////////    }
////////////////////////////
//////////////////////////////
//////////////////////////////    public int MAX_N = 31;
//////////////////////////////
//////////////////////////////    public int[] father = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int count = 0;
//////////////////////////////
//////////////////////////////    public boolean[] virus = new boolean[MAX_N];
//////////////////////////////
//////////////////////////////    public int[] cnts = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int[] infect = new int[MAX_N];
//////////////////////////////
//////////////////////////////
//////////////////////////////    public int[] size = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int n, m;
//////////////////////////////
//////////////////////////////    public int[][] grid;
//////////////////////////////
//////////////////////////////    public int[] hitBricks(int[][] g, int[][] h) {
//////////////////////////////        grid = g;
//////////////////////////////        n = grid.length;
//////////////////////////////        m = grid[0].length;
//////////////////////////////        int[] ans = new int[h.length];
//////////////////////////////        if (n == 1) {
//////////////////////////////            return ans;
//////////////////////////////        }
//////////////////////////////        for (int[] x : h) {
//////////////////////////////            grid[x[0]][x[1]]--;
//////////////////////////////        }
//////////////////////////////        for (int i = 0; i < m; i++) {
//////////////////////////////            dfs(0, i);
//////////////////////////////        }
//////////////////////////////        for (int i = h.length - 1; i >= 0; i--) {
//////////////////////////////            int row = h[i][0];
//////////////////////////////            int col = h[i][1];
//////////////////////////////            grid[row][col]++;
//////////////////////////////            if (worth(row, col)) {
//////////////////////////////                ans[i] = dfs(row, col) - 1;
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private boolean worth(int row, int col) {
//////////////////////////////        return grid[row][col] == 1 &&
//////////////////////////////                (row == 0
//////////////////////////////                        || (row > 0 && grid[row - 1][col] == 2)
//////////////////////////////                        || (row + 1 < n && grid[row + 1][col] == 2)
//////////////////////////////                        || (col + 1 < m && grid[row][col + 1] == 2)
//////////////////////////////                        || (col > 0 && grid[row][col - 1] == 2));
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private int dfs(int i, int j) {
//////////////////////////////        if (i < 0 || i == n || j < 0 || j == m || grid[i][j] != 1) {
//////////////////////////////            return 0;
//////////////////////////////        }
//////////////////////////////        grid[i][j] = 2;
//////////////////////////////        return 1 + dfs(i - 1, j) + dfs(i + 1, j) + dfs(i, j - 1) + dfs(i, j + 1);
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int largestIsland(int[][] grid) {
//////////////////////////////        int n = grid.length;
//////////////////////////////        int m = grid[0].length;
//////////////////////////////        int id = 2;
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < m; j++) {
//////////////////////////////                if (grid[i][j] == 1) {
//////////////////////////////                    dfs(grid, n, m, i, j, id++);
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        int ans = 0;
//////////////////////////////        int[] cnt = new int[id];
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < m; j++) {
//////////////////////////////                if (grid[i][j] > 1) {
//////////////////////////////                    ans = Math.max(ans, ++cnt[grid[i][j]]);
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        boolean[] visit = new boolean[id];
//////////////////////////////        int up, left, right, down, sum;
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < n; j++) {
//////////////////////////////                if (grid[i][j] == 0) {
//////////////////////////////                    up = i > 0 ? grid[i - 1][j] : 0;
//////////////////////////////                    down = i + 1 < n ? grid[i + 1][j] : 0;
//////////////////////////////                    left = j > 0 ? grid[i][j - 1] : 0;
//////////////////////////////                    right = j + 1 < n ? grid[i][j + 1] : 0;
//////////////////////////////                    sum = 1 + cnt[up];
//////////////////////////////                    visit[up] = true;
//////////////////////////////                    if (!visit[down]) {
//////////////////////////////                        sum += cnt[down];
//////////////////////////////                        visit[down] = true;
//////////////////////////////                    }
//////////////////////////////                    if (!visit[left]) {
//////////////////////////////                        sum += cnt[left];
//////////////////////////////                        visit[left] = true;
//////////////////////////////                    }
//////////////////////////////                    if (!visit[right]) {
//////////////////////////////                        sum += cnt[right];
//////////////////////////////                        visit[right] = true;
//////////////////////////////                    }
//////////////////////////////                    ans = Math.max(ans, sum);
//////////////////////////////                    visit[up] = false;
//////////////////////////////                    visit[down] = false;
//////////////////////////////                    visit[left] = false;
//////////////////////////////                    visit[right] = false;
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private void dfs(int[][] grid, int n, int m, int i, int j, int id) {
//////////////////////////////        if (i < 0 || i == n || j < 0 || j == m || grid[i][j] != 1) {
//////////////////////////////            return;
//////////////////////////////        }
//////////////////////////////        grid[i][j] = id;
//////////////////////////////        dfs(grid, n, m, i - 1, j, id);
//////////////////////////////        dfs(grid, n, m, i + 1, j, id);
//////////////////////////////        dfs(grid, n, m, i, j - 1, id);
//////////////////////////////        dfs(grid, n, m, i, j + 1, id);
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public void solve(char[][] board) {
//////////////////////////////        int n = board.length;
//////////////////////////////        int m = board[0].length;
//////////////////////////////        for (int j = 0; j < m; j++) {
//////////////////////////////            if (board[0][j] == 'O') {
//////////////////////////////                dfs(board, n, m, 0, j);
//////////////////////////////            }
//////////////////////////////            if (board[n - 1][j] == 'O') {
//////////////////////////////                dfs(board, n, m, n - 1, j);
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        for (int i = 1; i < n - 1; i++) {
//////////////////////////////            if (board[i][0] == 'O') {
//////////////////////////////                dfs(board, n, m, i, 0);
//////////////////////////////            }
//////////////////////////////            if (board[i][m - 1] == 'O') {
//////////////////////////////                dfs(board, n, m, i, m - 1);
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < m; j++) {
//////////////////////////////                if (board[i][j] == 'O') {
//////////////////////////////                    board[i][j] = 'X';
//////////////////////////////                }
//////////////////////////////                if (board[i][j] == 'F') {
//////////////////////////////                    board[i][j] = 'O';
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private void dfs(char[][] board, int n, int m, int i, int j) {
//////////////////////////////        if (i < 0 || i == n || j < 0 || j == m || board[i][j] != 'O') {
//////////////////////////////            return;
//////////////////////////////        }
//////////////////////////////        board[i][j] = 'F';
//////////////////////////////        dfs(board, n, m, i - 1, j);
//////////////////////////////        dfs(board, n, m, i + 1, j);
//////////////////////////////        dfs(board, n, m, i, j - 1);
//////////////////////////////        dfs(board, n, m, i, j + 1);
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int numIslands(char[][] grid) {
//////////////////////////////        int n = grid.length;
//////////////////////////////        int m = grid[0].length;
//////////////////////////////        int count = 0;
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < m; j++) {
//////////////////////////////                if (grid[i][j] == '1') {
//////////////////////////////                    count++;
//////////////////////////////                    dfs(grid, i, j);
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        return count;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private void dfs(char[][] grid, int i, int j) {
//////////////////////////////        if (i < 0 || i == grid.length || j < 0 || j == grid.length || grid[i][j] != '1') {
//////////////////////////////            return;
//////////////////////////////        }
//////////////////////////////        grid[i][j] = '0';
//////////////////////////////        dfs(grid, i - 1, j);
//////////////////////////////        dfs(grid, i + 1, j);
//////////////////////////////        dfs(grid, i, j - 1);
//////////////////////////////        dfs(grid, i, j + 1);
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public void build(int n, int[] initial) {
//////////////////////////////        for (int i = 0; i <= n; i++) {
//////////////////////////////            virus[i] = false;
//////////////////////////////            father[i] = i;
//////////////////////////////            infect[i] = -1;
//////////////////////////////            cnts[i] = 0;
//////////////////////////////            size[i] = 1;
//////////////////////////////        }
//////////////////////////////        for (int x : initial) {
//////////////////////////////            virus[x] = true;
//////////////////////////////        }
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int find(int i) {
//////////////////////////////        if (i != father[i]) {
//////////////////////////////            father[i] = find(father[i]);
//////////////////////////////        }
//////////////////////////////        return father[i];
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public void union(int x, int y) {
//////////////////////////////        int fx = find(x);
//////////////////////////////        int fy = find(y);
//////////////////////////////        if (fx != fy) {
//////////////////////////////            father[fx] = fy;
//////////////////////////////            size[fy] += size[fx];
//////////////////////////////        }
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int minMalwareSpread(int[][] graph, int[] initial) {
//////////////////////////////        int n = graph.length;
//////////////////////////////        build(n, initial);
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < n; j++) {
//////////////////////////////                if (graph[i][j] == 1 && !virus[j] && !virus[i]) {
//////////////////////////////                    union(i, j);
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////
//////////////////////////////        for (int sick : initial) {
//////////////////////////////            for (int i = 0; i < n; i++) {
//////////////////////////////                if (sick != i && !virus[i] && graph[sick][i] == 1) {
//////////////////////////////                    int fn = find(i);
//////////////////////////////                    if (infect[fn] == -1) {
//////////////////////////////                        infect[fn] = sick;
//////////////////////////////                    } else if (infect[fn] != -2 && infect[fn] != sick) {
//////////////////////////////                        infect[fn] = -2;
//////////////////////////////                    }
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            if (i == find(i) && infect[i] >= 0) {
//////////////////////////////                cnts[infect[i]] += size[i];
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        Arrays.sort(initial);
//////////////////////////////        int ans = initial[0];
//////////////////////////////        int max = cnts[ans];
//////////////////////////////        for (int i : initial) {
//////////////////////////////            if (cnts[i] > max) {
//////////////////////////////                ans = i;
//////////////////////////////                max = cnts[i];
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int[] maxcnt = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public void build(int n) {
//////////////////////////////        for (int i = 0; i <= n; i++) {
//////////////////////////////            father[i] = i;
//////////////////////////////            maxcnt[i] = 1;
//////////////////////////////        }
//////////////////////////////    }
//////////////////////////////
////////////////////////////////    public int find(int x) {
////////////////////////////////        if (x != father[x]) {
////////////////////////////////            father[x] = find(father[x]);
////////////////////////////////        }
////////////////////////////////        return father[x];
////////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int union(int x, int y, int[] val) {
//////////////////////////////        int fx = find(x);
//////////////////////////////        int fy = find(y);
//////////////////////////////        int ans = 0;
//////////////////////////////        if (val[fx] > val[fy]) {
//////////////////////////////            father[fy] = fx;
//////////////////////////////        } else if (val[fy] > val[fx]) {
//////////////////////////////            father[fx] = fy;
//////////////////////////////        } else {
//////////////////////////////            ans = maxcnt[fx] * maxcnt[fy];
//////////////////////////////            father[fx] = fy;
//////////////////////////////            maxcnt[fy] += maxcnt[fx];
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int numberOfGoodPaths(int[] vals, int[][] edges) {
//////////////////////////////        int n = vals.length;
//////////////////////////////        build(n);
//////////////////////////////        int ans = n;
//////////////////////////////        Arrays.sort(edges, (a, b) -> (Math.max(vals[a[0]], vals[a[1]]) - Math.max(vals[b[0]], vals[b[1]])));
//////////////////////////////        for (int[] edge : edges) {
//////////////////////////////            ans += union(edge[0], edge[1], vals);
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public boolean[] secret = new boolean[MAX_N];
//////////////////////////////
////////////////////////////////    public void build(int n, int first) {
////////////////////////////////        for (int i = 0; i <= n; i++) {
////////////////////////////////            father[i] = i;
////////////////////////////////            secret[i] = false;
////////////////////////////////        }
////////////////////////////////        count = n;
////////////////////////////////        father[first] = 0;
////////////////////////////////        secret[0] = true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int find(int x) {
////////////////////////////////        if (x != father[x]) {
////////////////////////////////            father[x] = find(father[x]);
////////////////////////////////        }
////////////////////////////////        return father[x];
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public void union(int x, int y) {
////////////////////////////////        int fx = find(x);
////////////////////////////////        int fy = find(y);
////////////////////////////////        if (fx != fy) {
////////////////////////////////            father[fx] = fy;
////////////////////////////////            secret[fy] |= secret[fx];
////////////////////////////////            count--;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
////////////////////////////////        build(n, firstPerson);
////////////////////////////////        int m = meetings.length;
////////////////////////////////        Arrays.sort(meetings, 0, m, (a, b) -> a[2] - b[2]);
////////////////////////////////        for (int l = 0, r; l < m; ) {
////////////////////////////////            r = l;
////////////////////////////////            while (r + 1 < m && meetings[l][2] == meetings[r + 1][2]) {
////////////////////////////////                r++;
////////////////////////////////            }
////////////////////////////////            for (int i = l; i <= r; i++) {
////////////////////////////////                int a = meetings[i][0];
////////////////////////////////                int b = meetings[i][1];
////////////////////////////////                union(a, b);
////////////////////////////////            }
////////////////////////////////            for (int i = l; i <= r; i++) {
////////////////////////////////                int a = meetings[i][0];
////////////////////////////////                int b = meetings[i][1];
////////////////////////////////                if (!secret[find(a)]) {
////////////////////////////////                    father[a] = a;
////////////////////////////////                }
////////////////////////////////                if (!secret[find(b)]) {
////////////////////////////////                    father[b] = b;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            l = r + 1;
////////////////////////////////        }
////////////////////////////////        List<Integer> ans = new ArrayList<>();
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            if (secret[find(i)]) {
////////////////////////////////                ans.add(i);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
//////////////////////////////
////////////////////////////////    public void build(int m) {
////////////////////////////////        rowMap.clear();
////////////////////////////////        colMap.clear();
////////////////////////////////        for (int i = 0; i <= m; i++) {
////////////////////////////////            father[i] = i;
////////////////////////////////        }
////////////////////////////////        count = m;
////////////////////////////////    }
//////////////////////////////
////////////////////////////////    public int find(int x) {
////////////////////////////////        if (x != father[x]) {
////////////////////////////////            father[x] = find(father[x]);
////////////////////////////////        }
////////////////////////////////        return father[x];
////////////////////////////////    }
//////////////////////////////
////////////////////////////////    public boolean isSameSet(int x, int y) {
////////////////////////////////        return find(x) == find(y);
////////////////////////////////    }
//////////////////////////////
////////////////////////////////    public void union(int x, int y) {
////////////////////////////////        int fx = find(x);
////////////////////////////////        int fy = find(y);
////////////////////////////////        if (fx != fy) {
////////////////////////////////            father[fx] = fy;
////////////////////////////////            count--;
////////////////////////////////        }
////////////////////////////////    }
//////////////////////////////
////////////////////////////////    public HashMap<Integer, Integer> rowMap = new HashMap<>();
////////////////////////////////
////////////////////////////////    public HashMap<Integer, Integer> colMap = new HashMap<>();
////////////////////////////////
////////////////////////////////    public int removeStones(int[][] stones) {
////////////////////////////////        int n = stones.length;
////////////////////////////////        build(n);
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            int row = stones[i][0];
////////////////////////////////            int col = stones[i][1];
////////////////////////////////            if (!rowMap.containsKey(row)) {
////////////////////////////////                rowMap.put(row, i);
////////////////////////////////            } else {
////////////////////////////////                union(i, rowMap.get(row));
////////////////////////////////            }
////////////////////////////////            if (!colMap.containsKey(col)) {
////////////////////////////////                colMap.put(col, i);
////////////////////////////////            } else {
////////////////////////////////                union(i, colMap.get(col));
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return n - count;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public void build(char[][] grid, int n, int m) {
////////////////////////////////        count = 0;
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////////////                if (grid[i][j] == '1') {
////////////////////////////////                    int index = getIndex(i, j, m);
////////////////////////////////                    father[index] = index;
////////////////////////////////                    count++;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int getIndex(int i, int j, int m) {
////////////////////////////////        return i * m + j;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public void union(int a, int b, int c, int d, int m) {
////////////////////////////////        int fx = find(getIndex(a, b, m));
////////////////////////////////        int fy = find(getIndex(c, d, m));
////////////////////////////////        if (fx != fy) {
////////////////////////////////            father[fx] = fy;
////////////////////////////////            count--;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int numIslands(char[][] grid) {
////////////////////////////////        int n = grid.length;
////////////////////////////////        int m = grid[0].length;
////////////////////////////////        build(grid, n, m);
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////////////                if (grid[i][j] == '1') {
////////////////////////////////                    if (j > 0 && grid[i][j - 1] == '1') {
////////////////////////////////                        union(i, j, i, j - 1, m);
////////////////////////////////                    }
////////////////////////////////                    if (i > 0 && grid[i - 1][j] == '1') {
////////////////////////////////                        union(i, j, i - 1, j, m);
////////////////////////////////                    }
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return count;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int numSimilarGroups(String[] strs) {
////////////////////////////////        int n = strs.length;
////////////////////////////////        int m = strs[0].length();
////////////////////////////////        build(m);
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            for (int j = i + 1; j < n; j++) {
////////////////////////////////                if (find(i) != find(j)) {
////////////////////////////////                    int diff = 0;
////////////////////////////////                    for (int k = 0; k < m && diff < 3; k++) {
////////////////////////////////                        if (strs[i].charAt(k) != strs[j].charAt(k)) {
////////////////////////////////                            diff++;
////////////////////////////////                        }
////////////////////////////////                    }
////////////////////////////////                    if (diff == 0 || diff == 2) {
////////////////////////////////                        union(i, j);
////////////////////////////////                    }
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return count;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int minSwapsCouples(int[] row) {
////////////////////////////////        int n = row.length;
////////////////////////////////        build(n / 2);
////////////////////////////////        for (int i = 0; i < n; i += 2) {
////////////////////////////////            union(row[i] / 2, row[i + 1] / 2);
////////////////////////////////        }
////////////////////////////////        return n / 2 - count;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int MOD = 1000000007;
////////////////////////////////
////////////////////////////////    public int MAX_N = 1000001;
////////////////////////////////    public int arr[] = new int[MAX_N];
////////////////////////////////
////////////////////////////////    public int fib(int n) {
////////////////////////////////        if (n == 0) {
////////////////////////////////            return 0;
////////////////////////////////        }
////////////////////////////////        if (n == 1) {
////////////////////////////////            return 1;
////////////////////////////////        }
////////////////////////////////        if (arr[n] != 0) {
////////////////////////////////            return arr[n];
////////////////////////////////        }
////////////////////////////////        arr[n] = fib(n - 1) % MOD + fib(n - 2) % MOD;
////////////////////////////////        return fib(n - 1) % MOD + fib(n - 2) % MOD;
////////////////////////////////    }
//////////////////////////////
//////////////////////////////
//////////////////////////////    public int[] maxdeq = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int[] mindeq = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int maxh, maxt, minh, mint;
//////////////////////////////
//////////////////////////////
//////////////////////////////    public int longestSubarray(int[] nums, int limit) {
//////////////////////////////        maxh = maxt = minh = mint = 0;
//////////////////////////////        int n = nums.length;
//////////////////////////////        arr = nums;
//////////////////////////////        int ans = 0;
//////////////////////////////        for (int l = 0, r = 0; l < n; l++) {
//////////////////////////////            while (r < n && ok(limit, nums[r])) {
//////////////////////////////                push(r++);
//////////////////////////////            }
//////////////////////////////            ans = Math.max(ans, r - l);
//////////////////////////////            pop(l);
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private void pop(int l) {
//////////////////////////////        if (maxh < maxt && maxdeq[maxh] == l) {
//////////////////////////////            maxh++;
//////////////////////////////        }
//////////////////////////////        if (minh < mint && mindeq[minh] == l) {
//////////////////////////////            minh++;
//////////////////////////////        }
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private void push(int i) {
//////////////////////////////        while (maxh < maxt && arr[i] >= arr[maxdeq[maxt - 1]]) {
//////////////////////////////            maxt--;
//////////////////////////////        }
//////////////////////////////        maxdeq[maxt++] = i;
//////////////////////////////        while (minh < mint && arr[i] <= arr[mindeq[mint - 1]]) {
//////////////////////////////            mint--;
//////////////////////////////        }
//////////////////////////////        mindeq[mint++] = i;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    private boolean ok(int limit, int num) {
//////////////////////////////        int max = maxh == maxt ? num : Math.max(arr[maxdeq[maxh]], num);
//////////////////////////////        int min = minh == mint ? num : Math.min(arr[mindeq[minh]], num);
//////////////////////////////        return max - min <= limit;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int[] dequeue = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int h, t;
//////////////////////////////
//////////////////////////////    public int[] maxSlidingWindow(int[] nums, int k) {
//////////////////////////////        h = t = 0;
//////////////////////////////        int n = nums.length;
//////////////////////////////        for (int i = 0; i < k - 1; i++) {
//////////////////////////////            while (h < t && nums[i] >= nums[dequeue[t - 1]]) {
//////////////////////////////                t--;
//////////////////////////////            }
//////////////////////////////            dequeue[t++] = i;
//////////////////////////////        }
//////////////////////////////        int m = n - k + 1;
//////////////////////////////        int[] ans = new int[m];
//////////////////////////////        for (int l = 0, r = k - 1; l < m; l++, r++) {
//////////////////////////////            while (h < t && nums[r] >= nums[dequeue[t - 1]]) {
//////////////////////////////                t--;
//////////////////////////////            }
//////////////////////////////            dequeue[t++] = r;
//////////////////////////////            ans[l] = nums[dequeue[h]];
//////////////////////////////            if (l == dequeue[h]) {
//////////////////////////////                h++;
//////////////////////////////            }
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int[] stack = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int[] heights = new int[MAX_N];
//////////////////////////////
//////////////////////////////    public int size;
//////////////////////////////
//////////////////////////////    public int numSubmat(int[][] mat) {
//////////////////////////////        int n = mat.length;
//////////////////////////////        int m = mat[0].length;
//////////////////////////////        Arrays.fill(heights, 0, m, 0);
//////////////////////////////        int ans = 0;
//////////////////////////////        for (int i = 0; i < n; i++) {
//////////////////////////////            for (int j = 0; j < m; j++) {
//////////////////////////////                heights[j] = mat[i][j] == 0 ? 0 : heights[j] + 1;
//////////////////////////////            }
//////////////////////////////            ans += countFromBottom(m);
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
//////////////////////////////    public int countFromBottom(int m) {
//////////////////////////////        int ans = 0;
//////////////////////////////        for (int i = 0; i < m; i++) {
//////////////////////////////            while (size > 0 && heights[stack[size - 1]] >= heights[i]) {
//////////////////////////////                int cur = stack[--size];
//////////////////////////////                if (heights[cur] > heights[i]) {
//////////////////////////////                    int left = size == 0 ? -1 : stack[size - 1];
//////////////////////////////                    int len = i - left - 1;
//////////////////////////////                    int bottom = Math.max(left == -1 ? 0 : heights[left], heights[i]);
//////////////////////////////                    ans += (heights[cur] - bottom) * len * (len + 1) / 2;
//////////////////////////////                }
//////////////////////////////            }
//////////////////////////////            stack[size++] = i;
//////////////////////////////        }
//////////////////////////////        while (size > 0) {
//////////////////////////////            int cur = stack[--size];
//////////////////////////////            int left = size == 0 ? -1 : stack[size - 1];
//////////////////////////////            int len = m - left - 1;
//////////////////////////////            int bottom = left == -1 ? 0 : heights[left];
//////////////////////////////            ans += (heights[cur] - bottom) * len * (len + 1) / 2;
//////////////////////////////        }
//////////////////////////////        return ans;
//////////////////////////////    }
//////////////////////////////
////////////////////////////////    public int totalSteps(int[] nums) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int i = n - 1; i >= 0; i--) {
////////////////////////////////            int curAns = 0;
////////////////////////////////            while (size > 0 && stack[size - 1][0] < nums[i]) {
////////////////////////////////                curAns = Math.max(curAns + 1, stack[--size][1]);
////////////////////////////////            }
////////////////////////////////            stack[size][0] = nums[i];
////////////////////////////////            stack[size++][1] = curAns;
////////////////////////////////            ans = Math.max(ans, curAns);
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
//////////////////////////////
////////////////////////////////    public int[] cnts = new int[MAX_N];
////////////////////////////////
////////////////////////////////    public boolean[] enters = new boolean[MAX_N];
////////////////////////////////
////////////////////////////////    public String removeDuplicateLetters(String s) {
////////////////////////////////        Arrays.fill(enters, false);
////////////////////////////////        Arrays.fill(cnts, 0);
////////////////////////////////        char[] charArr = s.toCharArray();
////////////////////////////////        for (int i = 0; i < charArr.length; i++) {
////////////////////////////////            cnts[charArr[i] - 'a']++;
////////////////////////////////        }
////////////////////////////////        for (int i = 0; i < charArr.length; i++) {
////////////////////////////////            if (!enters[charArr[i] - 'a']) {
////////////////////////////////                while (size > 0 && charArr[i] <= stack[size - 1] && cnts[stack[size - 1] - 'a'] > 0) {
////////////////////////////////                    enters[stack[size - 1] - 'a'] = false;
////////////////////////////////                    size--;
////////////////////////////////                }
////////////////////////////////                stack[size++] = charArr[i];
////////////////////////////////                enters[charArr[i] - 'a'] = true;
////////////////////////////////            }
////////////////////////////////            cnts[charArr[i] - 'a']--;
////////////////////////////////        }
////////////////////////////////        return String.valueOf(stack, 0, size);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int maxWidthRamp(int[] nums) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        size = 1;
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////            if (nums[i] < nums[stack[size - 1]]) {
////////////////////////////////                stack[size++] = i;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        for (int i = n - 1; i >= 0; i--) {
////////////////////////////////            while (size > 0 && nums[i] > nums[stack[size - 1]]) {
////////////////////////////////                int cur = stack[--size];
////////////////////////////////                ans = Math.max(ans, i - cur);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int[] heights = new int[MAX_N];
////////////////////////////////
////////////////////////////////    public int maximalRectangle(char[][] matrix) {
////////////////////////////////        int n = matrix.length;
////////////////////////////////        int m = matrix[0].length;
////////////////////////////////        Arrays.fill(heights, 0, m, 0);
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////////////                heights[j] = matrix[i][j] == '1' ? heights[j] + 1 : 0;
////////////////////////////////            }
////////////////////////////////            ans = Math.max(ans, largestRectangleArea(m));
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int largestRectangleArea(int m) {
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int i = 0; i < m; i++) {
////////////////////////////////            while (size > 0 && heights[i] <= heights[stack[size - 1]]) {
////////////////////////////////                int cur = stack[--size];
////////////////////////////////                int left = size > 0 ? stack[size - 1] : -1;
////////////////////////////////                ans = Math.max(ans, (i - left - 1) * heights[cur]);
////////////////////////////////            }
////////////////////////////////            stack[size++] = i;
////////////////////////////////        }
////////////////////////////////        while (size > 0) {
////////////////////////////////            int cur = stack[--size];
////////////////////////////////            int left = size > 0 ? stack[size - 1] : -1;
////////////////////////////////            ans = Math.max(ans, (m - left - 1) * heights[cur]);
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int MOD = 1000000007;
////////////////////////////////
////////////////////////////////    public int sumSubarrayMins(int[] arr) {
////////////////////////////////        int n = arr.length;
////////////////////////////////        long ans = 0;
////////////////////////////////        for (int i = 0; i < arr.length; i++) {
////////////////////////////////            while (size > 0 && arr[i] <= arr[stack[size - 1]]) {
////////////////////////////////                int cur = stack[--size];
////////////////////////////////                int left = size > 0 ? stack[size - 1] : -1;
////////////////////////////////                ans = (ans + (long) (cur - left) * (i - cur) * arr[cur]) % MOD;
////////////////////////////////            }
////////////////////////////////            stack[size++] = i;
////////////////////////////////        }
////////////////////////////////        while (size > 0) {
////////////////////////////////            int cur = stack[--size];
////////////////////////////////            int left = size > 0 ? stack[size - 1] : -1;
////////////////////////////////            ans = (ans + (long) (cur - left) * (n - cur) * arr[cur]) % MOD;
////////////////////////////////        }
////////////////////////////////        return (int) ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int[] dailyTemperatures(int[] temperatures) {
////////////////////////////////        Stack<Integer> stack = new Stack<>();
////////////////////////////////        int n = temperatures.length;
////////////////////////////////        int[] ans = new int[n];
////////////////////////////////        for (int i = 0; i < temperatures.length; i++) {
////////////////////////////////            int x = temperatures[i];
////////////////////////////////            while (!stack.isEmpty() && x >= temperatures[stack.peek()]) {
////////////////////////////////                int cur = stack.pop();
////////////////////////////////                ans[cur] = i;
////////////////////////////////            }
////////////////////////////////            stack.push(i);
////////////////////////////////        }
////////////////////////////////        while (!stack.isEmpty()) {
////////////////////////////////            int cur = stack.pop();
////////////////////////////////            ans[cur] = 0;
////////////////////////////////        }
////////////////////////////////        for (int i = n - 2; i >= 0; i--) {
////////////////////////////////            if (ans[i] != 0 && temperatures[i] == temperatures[ans[i]]) {
////////////////////////////////                ans[i] = ans[ans[i]];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        for (int i = 0; i < ans.length; i++) {
////////////////////////////////            if (ans[i] != 0) {
////////////////////////////////                ans[i] = ans[i] - i;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public long maxRunTime(int n, int[] batteries) {
////////////////////////////////        long sum = 0;
////////////////////////////////        long max = 0;
////////////////////////////////        for (int i = 0; i < batteries.length; i++) {
////////////////////////////////            max = Math.max(max, batteries[i]);
////////////////////////////////            sum += batteries[i];
////////////////////////////////        }
////////////////////////////////        if (sum > (long) max * n) {
////////////////////////////////            return sum / n;
////////////////////////////////        }
////////////////////////////////        long l = 0;
////////////////////////////////        long r = max;
////////////////////////////////        long ans = 0;
////////////////////////////////        long m = 0;
////////////////////////////////        while (l <= r) {
////////////////////////////////            m = l + ((r - l) >> 1);
////////////////////////////////            if (f(batteries, n, m)) {
////////////////////////////////                ans = m;
////////////////////////////////                l = m + 1;
////////////////////////////////            } else {
////////////////////////////////                r = m - 1;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private boolean f(int[] batteries, int num, long time) {
////////////////////////////////        long sum = 0;
////////////////////////////////        for (int battery : batteries) {
////////////////////////////////            if (battery > time) {
////////////////////////////////                num--;
////////////////////////////////            } else {
////////////////////////////////                sum += battery;
////////////////////////////////            }
////////////////////////////////            if (sum >= (long) num * time) {
////////////////////////////////                return true;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return false;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public class StringPattern {
////////////////////////////////
////////////////////////////////
////////////////////////////////        public int findAppearance(String A, int lena, String B, int lenb) {
////////////////////////////////            char[] s1 = A.toCharArray();
////////////////////////////////            char[] s2 = B.toCharArray();
////////////////////////////////            return kmp(s1, s2);
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static int kmp(char[] s1, char[] s2) {
////////////////////////////////            int n = s1.length;
////////////////////////////////            int m = s2.length;
////////////////////////////////            int[] next = getNext(s2, m);
////////////////////////////////            int x = 0;
////////////////////////////////            int y = 0;
////////////////////////////////            while (x < n) {
////////////////////////////////                if (s1[x] == s2[y]) {
////////////////////////////////                    x++;
////////////////////////////////                    y++;
////////////////////////////////                } else if (y == 0) {
////////////////////////////////                    x++;
////////////////////////////////                } else {
////////////////////////////////                    y = next[y];
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            return y == m ? x - y : -1;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static int[] getNext(char[] s2, int m) {
////////////////////////////////            if (m == 1) return new int[]{-1};
////////////////////////////////            int[] next = new int[m];
////////////////////////////////            next[0] = -1;
////////////////////////////////            next[1] = 0;
////////////////////////////////            int i = 2;
////////////////////////////////            int cn = 0;
////////////////////////////////            while (i < m) {
////////////////////////////////                if (s2[i - 1] == s2[cn]) {
////////////////////////////////                    next[i++] = ++cn;
////////////////////////////////                } else if (cn > 0) {
////////////////////////////////                    cn = next[cn];
////////////////////////////////                } else {
////////////////////////////////                    next[i++] = 0;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            return next;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int smallestDistancePair(int[] nums, int k) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        Arrays.sort(nums);
////////////////////////////////        int l = 0;
////////////////////////////////        int r = nums[n - 1] - nums[0];
////////////////////////////////        int ans = 0;
////////////////////////////////        int m = 0;
////////////////////////////////        while (l <= r) {
////////////////////////////////            m = l + ((r - l) >> 1);
////////////////////////////////            if (f3(nums, m) >= k) {
////////////////////////////////                ans = m;
////////////////////////////////                r = m - 1;
////////////////////////////////            } else {
////////////////////////////////                l = m + 1;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int f3(int[] nums, int limit) {
////////////////////////////////        int ans = 0;
////////////////////////////////        int n = nums.length;
////////////////////////////////        for (int l = 0, r = 0; l < n; l++) {
////////////////////////////////            while (r + 1 < n && nums[r + 1] - nums[l] <= limit) {
////////////////////////////////                r++;
////////////////////////////////            }
////////////////////////////////            ans += r - l;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int splitArray(int[] nums, int k) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        long sum = 0;
////////////////////////////////        for (int num : nums) {
////////////////////////////////            sum += num;
////////////////////////////////        }
////////////////////////////////        long l = 0;
////////////////////////////////        long r = sum;
////////////////////////////////        long ans = 0;
////////////////////////////////        while (l <= r) {
////////////////////////////////            long m = (l + ((r - l) >> 1));
////////////////////////////////            int need = f2(nums, m);
////////////////////////////////            if (need <= k) {
////////////////////////////////                ans = m;
////////////////////////////////                r = m - 1;
////////////////////////////////            } else {
////////////////////////////////                l = m + 1;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return (int) ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int f2(int[] nums, long limit) {
////////////////////////////////        long sum = 0;
////////////////////////////////        int count = 1;
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////            if (nums[i] > limit) {
////////////////////////////////                return Integer.MAX_VALUE;
////////////////////////////////            } else if (sum + nums[i] > limit) {
////////////////////////////////                count++;
////////////////////////////////                sum = nums[i];
////////////////////////////////            } else {
////////////////////////////////                sum += nums[i];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return count;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int minEatingSpeed(int[] piles, int h) {
////////////////////////////////        int l = 1;
////////////////////////////////        int r = 0;
////////////////////////////////        for (int pile : piles) {
////////////////////////////////            r = Math.max(r, pile);
////////////////////////////////        }
////////////////////////////////        int ans = 0;
////////////////////////////////        int m = 0;
////////////////////////////////        while (l <= r) {
////////////////////////////////            m = l + ((r - l) >> 1);
////////////////////////////////            if (f(piles, m) <= h) {
////////////////////////////////                ans = m;
////////////////////////////////                r = m - 1;
////////////////////////////////            } else {
////////////////////////////////                l = m + 1;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public long f(int[] piles, int m) {
////////////////////////////////        long ans = 0;
////////////////////////////////        for (int pile : piles) {
////////////////////////////////            ans += (pile + m - 1) / m;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int firstMissingPositive(int[] nums) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        int l = 0;
////////////////////////////////        int r = n;
////////////////////////////////        while (l < r) {
////////////////////////////////            if (nums[l] == l + 1) {
////////////////////////////////                l++;
////////////////////////////////            } else if (nums[l] <= l || nums[l] > r || nums[nums[l] - 1] == nums[l]) {
////////////////////////////////                swap(nums, l, --r);
////////////////////////////////            } else {
////////////////////////////////                swap(nums, l, nums[l] - 1);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return l + 1;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void swap(int[] nums, int i, int j) {
////////////////////////////////        int tmp = nums[i];
////////////////////////////////        nums[i] = nums[j];
////////////////////////////////        nums[j] = tmp;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int findRadius(int[] houses, int[] heaters) {
////////////////////////////////        int ans = 0;
////////////////////////////////        Arrays.sort(houses);
////////////////////////////////        Arrays.sort(heaters);
////////////////////////////////        for (int i = 0, j = 0; i < houses.length; i++) {
////////////////////////////////            while (!best(houses, heaters, i, j)) {
////////////////////////////////                j++;
////////////////////////////////            }
////////////////////////////////            ans = Math.max(ans, Math.abs(heaters[j] - houses[i]));
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private boolean best(int[] houses, int[] heaters, int i, int j) {
////////////////////////////////        return j == heaters.length
////////////////////////////////                ||
////////////////////////////////                Math.abs(heaters[j] - houses[i]) < Math.abs(heaters[j + 1] - houses[i]);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int maxArea(int[] height) {
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int l = 0, r = height.length - 1; l < r; ) {
////////////////////////////////            ans = Math.max(ans, Math.min(height[l], height[r]) * (r - l));
////////////////////////////////            if (height[l] >= height[r]) {
////////////////////////////////                l++;
////////////////////////////////            } else {
////////////////////////////////                r--;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int numRescueBoats(int[] people, int limit) {
////////////////////////////////        Arrays.sort(people);
////////////////////////////////        int l = 0;
////////////////////////////////        int r = people.length - 1;
////////////////////////////////        int sum = 0;
////////////////////////////////        int ans = 0;
////////////////////////////////        while (l <= r) {
////////////////////////////////            sum = l == r ? people[l] : people[l] + people[r];
////////////////////////////////            if (sum > limit) {
////////////////////////////////                r--;
////////////////////////////////            } else {
////////////////////////////////                l++;
////////////////////////////////                r--;
////////////////////////////////            }
////////////////////////////////            ans++;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int trap(int[] height) {
////////////////////////////////        int n = height.length;
////////////////////////////////        int l = 1;
////////////////////////////////        int r = n - 1;
////////////////////////////////        int lmax = height[0];
////////////////////////////////        int rmax = height[n - 1];
////////////////////////////////        int ans = 0;
////////////////////////////////        while (l <= r) {
////////////////////////////////            if (lmax <= rmax) {
////////////////////////////////                ans += Math.max(0, lmax - height[l]);
////////////////////////////////                lmax = Math.max(lmax, height[l++]);
////////////////////////////////            } else {
////////////////////////////////                ans += Math.max(0, rmax - height[r]);
////////////////////////////////                rmax = Math.max(rmax, height[r++]);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int findDuplicate(int[] nums) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        int fast = 0;
////////////////////////////////        int slow = 0;
////////////////////////////////        do {
////////////////////////////////            fast = nums[nums[fast]];
////////////////////////////////            slow = nums[slow];
////////////////////////////////        } while (fast != slow);
////////////////////////////////        fast = 0;
////////////////////////////////        do {
////////////////////////////////            fast = nums[fast];
////////////////////////////////            slow = nums[slow];
////////////////////////////////        } while (fast != slow);
////////////////////////////////        return fast;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int[] sortArrayByParityII(int[] nums) {
////////////////////////////////        int n = nums.length;
////////////////////////////////        for (int i = 0, j = 1; i < n && j < n; ) {
////////////////////////////////            if (nums[n - 1] % 2 == 0) {
////////////////////////////////                swap(nums, j, n - 1);
////////////////////////////////                j += 2;
////////////////////////////////            } else {
////////////////////////////////                swap(nums, i, n - 1);
////////////////////////////////                i += 2;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return nums;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int longestSubstring(String str, int k) {
////////////////////////////////        char[] s = str.toCharArray();
////////////////////////////////        int n = s.length;
////////////////////////////////        int[] cnts = new int[256];
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int requirs = 1; requirs <= 26; requirs++) {
////////////////////////////////            Arrays.fill(cnts, 0);
////////////////////////////////            for (int l = 0, r = 0, collect = 0, statisfy = 0; r < n; r++) {
////////////////////////////////                cnts[s[r]]++;
////////////////////////////////                if (cnts[s[r]] == 1) {
////////////////////////////////                    collect++;
////////////////////////////////                }
////////////////////////////////                if (cnts[s[r]] == k) {
////////////////////////////////                    statisfy++;
////////////////////////////////                }
////////////////////////////////                while (collect > requirs) {
////////////////////////////////                    if (cnts[s[l]] == 1) {
////////////////////////////////                        collect--;
////////////////////////////////                    }
////////////////////////////////                    if (cnts[s[l]] == k) {
////////////////////////////////                        statisfy--;
////////////////////////////////                    }
////////////////////////////////                    cnts[s[l++]]--;
////////////////////////////////                }
////////////////////////////////                if (statisfy == requirs) {
////////////////////////////////                    ans = Math.max(ans, r - l + 1);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int subarraysWithKDistinct(int[] nums, int k) {
////////////////////////////////        return numLessAndequalK(nums, k) - numLessAndequalK(nums, k - 1);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public int MAX_N = 20001;
////////////////////////////////
////////////////////////////////    public int[] cnt = new int[MAX_N];
////////////////////////////////
////////////////////////////////    private int numLessAndequalK(int[] nums, int k) {
////////////////////////////////        Arrays.fill(cnt, 0, nums.length + 1, 0);
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int l = 0, r = 0, collect = 0; r < nums.length; r++) {
////////////////////////////////            if (++cnt[nums[r]] == 1) {
////////////////////////////////                collect++;
////////////////////////////////            }
////////////////////////////////            while (collect > k) {
////////////////////////////////                if (--cnt[nums[l++]] == 0) {
////////////////////////////////                    collect--;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            ans += r - l + 1;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static int balancedString(String str) {
////////////////////////////////        int n = str.length();
////////////////////////////////        int[] s = new int[n];
////////////////////////////////        int[] cnts = new int[4];
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            char c = str.charAt(i);
////////////////////////////////            s[i] = c == 'W' ? 1 : (c == 'E' ? 2 : (c == 'R' ? 3 : 0));
////////////////////////////////            cnts[s[i]]++;
////////////////////////////////        }
////////////////////////////////        int debt = 0;
////////////////////////////////        for (int i = 0; i < 4; i++) {
////////////////////////////////            if (cnts[i] < n / 4) {
////////////////////////////////                cnts[i] = 0;
////////////////////////////////            } else {
////////////////////////////////                cnts[i] = n / 4 - cnts[i];
////////////////////////////////                debt -= cnts[i];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        if (debt == 0) {
////////////////////////////////            return 0;
////////////////////////////////        }
////////////////////////////////        int ans = Integer.MAX_VALUE;
////////////////////////////////        for (int l = 0, r = 0; r < n; r++) {
////////////////////////////////            if (cnts[s[r]]++ < 0) {
////////////////////////////////                debt--;
////////////////////////////////            }
////////////////////////////////            if (debt == 0) {
////////////////////////////////                while (cnts[s[l]] > 0) {
////////////////////////////////                    cnts[s[l++]]--;
////////////////////////////////                }
////////////////////////////////                ans = Math.min(ans, r - l + 1);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int canCompleteCircuit(int[] gas, int[] cost) {
////////////////////////////////        int n = gas.length;
////////////////////////////////        for (int l = 0, r = 0, sum = 0; l < n; l = r + 1, r = l) {
////////////////////////////////            sum = 0;
////////////////////////////////            while (sum + gas[r % n] - cost[r % n] >= 0) {
////////////////////////////////                if (r - l + 1 == n) {
////////////////////////////////                    return l;
////////////////////////////////                }
////////////////////////////////                sum += gas[r % n] - cost[r % n];
////////////////////////////////                r++;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return -1;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public String minWindow(String s, String t) {
////////////////////////////////        if (s.length() < t.length()) return "";
////////////////////////////////        char[] sArr = s.toCharArray();
////////////////////////////////        char[] tArr = t.toCharArray();
////////////////////////////////        int[] cnt = new int[256];
////////////////////////////////        for (char c : tArr) {
////////////////////////////////            cnt[c]--;
////////////////////////////////        }
////////////////////////////////        int len = Integer.MAX_VALUE;
////////////////////////////////        int start = 0;
////////////////////////////////        for (int l = 0, r = 0, dept = tArr.length; r < sArr.length; r++) {
////////////////////////////////            if (cnt[sArr[r]] < 0) {
////////////////////////////////                dept--;
////////////////////////////////            }
////////////////////////////////            if (dept == 0) {
////////////////////////////////                while (cnt[sArr[l]] > 0) {
////////////////////////////////                    cnt[sArr[l]]--;
////////////////////////////////                    l++;
////////////////////////////////                }
////////////////////////////////                if (r - l + 1 < len) {
////////////////////////////////                    len = r - l + 1;
////////////////////////////////                    start = l;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int lengthOfLongestSubstring(String s) {
////////////////////////////////        int[] last = new int[255];
////////////////////////////////        int ans = 0;
////////////////////////////////        Arrays.fill(last, -1);
////////////////////////////////        for (int l = 0, r = 0; l < s.length(); l++) {
////////////////////////////////            l = Math.max(l, last[s.charAt(r)] + 1);
////////////////////////////////            ans = Math.max(ans, r - l + 1);
////////////////////////////////            last[s.charAt(r)] = r;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int minSubArrayLen(int target, int[] nums) {
////////////////////////////////        int ans = Integer.MAX_VALUE;
////////////////////////////////        int sum = 0;
////////////////////////////////        for (int l = 0, r = 0; r < nums.length; r++) {
////////////////////////////////            sum += nums[r];
////////////////////////////////            while (sum - nums[l] >= target) {
////////////////////////////////                sum -= nums[l++];
////////////////////////////////            }
////////////////////////////////            if (sum >= target) {
////////////////////////////////                ans = Math.min(ans, r - l + 1);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans == Integer.MAX_VALUE ? 0 : ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public boolean possibleToStamp(int[][] grid, int stampHeight, int stampWidth) {
////////////////////////////////        int n = grid.length;
////////////////////////////////        int m = grid[0].length;
////////////////////////////////        int[][] sum = new int[n + 1][m + 1];
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////////////                sum[i + 1][j + 1] = grid[i][j];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        build(sum);
////////////////////////////////        int[][] diff = new int[n + 2][m + 2];
////////////////////////////////        for (int a = 1, c = a + stampHeight - 1; c <= n; a++, c++) {
////////////////////////////////            for (int b = 1, d = b + stampWidth - 1; d <= m; b++, d++) {
////////////////////////////////                if (getSum(sum, a, b, c, d) == 0) {
////////////////////////////////                    addVal(diff, a, b, c, d);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        build(diff);
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            for (int j = 0; j < m; j++) {
////////////////////////////////                if (diff[i + 1][j + 1] == 0 && grid[i][j] == 0) {
////////////////////////////////                    return false;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void addVal(int[][] diff, int a, int b, int c, int d) {
////////////////////////////////        diff[a][b] += 1;
////////////////////////////////        diff[c + 1][d + 1] += 1;
////////////////////////////////        diff[a][d + 1] -= 1;
////////////////////////////////        diff[c + 1][b] -= 1;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int getSum(int[][] sum, int a, int b, int c, int d) {
////////////////////////////////        return sum[c][d] - sum[c][b - 1] - sum[a - 1][d] + sum[a - 1][b - 1];
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void build(int[][] sum) {
////////////////////////////////        int n = sum.length;
////////////////////////////////        int m = sum[0].length;
////////////////////////////////        for (int i = 1; i < n; i++) {
////////////////////////////////            for (int j = 1; j < m; j++) {
////////////////////////////////                sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int findTheLongestSubstring(String s) {
////////////////////////////////        int n = s.length();
////////////////////////////////        int[] map = new int[32];
////////////////////////////////        Arrays.fill(map, -2);
////////////////////////////////        map[0] = -1;
////////////////////////////////        int ans = 0;
////////////////////////////////        int status = 0;
////////////////////////////////        int m = 0;
////////////////////////////////        for (int i = 0; i < n; i++) {
////////////////////////////////            m = move(s.charAt(i));
////////////////////////////////            if (m != -1) {
////////////////////////////////                status ^= 1 << m;
////////////////////////////////            }
////////////////////////////////            if (map[status] != -2) {
////////////////////////////////                ans = Math.max(ans, i - map[status]);
////////////////////////////////            } else {
////////////////////////////////                map[status] = i;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int move(char c) {
////////////////////////////////        switch (c) {
////////////////////////////////            case 'a':
////////////////////////////////                return 0;
////////////////////////////////            case 'e':
////////////////////////////////                return 1;
////////////////////////////////            case 'i':
////////////////////////////////                return 2;
////////////////////////////////            case 'o':
////////////////////////////////                return 3;
////////////////////////////////            case 'u':
////////////////////////////////                return 4;
////////////////////////////////            default:
////////////////////////////////                return -1;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int[] corpFlightBookings(int[][] bookings, int n) {
////////////////////////////////        int[] arr = new int[n + 1];
////////////////////////////////        for (int i = 0; i < bookings.length; i++) {
////////////////////////////////            int from = bookings[i][0] - 1;
////////////////////////////////            int to = bookings[i][1];
////////////////////////////////            int val = bookings[i][2];
////////////////////////////////            arr[from] += val;
////////////////////////////////            arr[to] -= val;
////////////////////////////////        }
////////////////////////////////        System.out.print(arr[0] + " ");
////////////////////////////////        for (int i = 1; i < n; i++) {
////////////////////////////////            System.out.print(arr[i] + " ");
////////////////////////////////            arr[i] += arr[i - 1];
////////////////////////////////        }
////////////////////////////////        return Arrays.copyOfRange(arr, 0, n);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int subarraySum(int[] nums, int k) {
////////////////////////////////        HashMap<Integer, Integer> map = new HashMap<>();
////////////////////////////////        int sum = 0;
////////////////////////////////        int ans = 0;
////////////////////////////////        map.put(0, 1);
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////            sum += nums[i];
////////////////////////////////            ans += map.getOrDefault(sum - k, 0);
////////////////////////////////            map.put(sum, map.getOrDefault(sum, 0) + 1);
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int minSubarray(int[] nums, int p) {
////////////////////////////////        int mod = 0;
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////            mod = (mod + nums[i]) % p;
////////////////////////////////        }
////////////////////////////////        if (mod == 0) return 0;
////////////////////////////////        int ans = Integer.MAX_VALUE;
////////////////////////////////        HashMap<Integer, Integer> map = new HashMap<>();
////////////////////////////////        map.put(0, -1);
////////////////////////////////        int cur = 0;
////////////////////////////////        int find = 0;
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////            cur = (cur + nums[i]) % p;
////////////////////////////////            find = cur >= mod ? cur - mod : (cur - mod + p);
////////////////////////////////            if (map.containsKey(find)) {
////////////////////////////////                ans = Math.min(ans, i - map.get(find));
////////////////////////////////            }
////////////////////////////////            map.put(cur, i);
////////////////////////////////        }
////////////////////////////////        return ans == nums.length ? -1 : ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int longestWPI(int[] hours) {
////////////////////////////////        HashMap<Integer, Integer> map = new HashMap<>();
////////////////////////////////        int ans = 0;
////////////////////////////////        map.put(0, -1);
////////////////////////////////        int sum = 0;
////////////////////////////////        for (int i = 0; i < hours.length; i++) {
////////////////////////////////            sum += hours[i] > 8 ? 1 : -1;
////////////////////////////////            if (sum > 0) {
////////////////////////////////                ans = Math.max(ans, i + 1);
////////////////////////////////            } else {
////////////////////////////////                if (map.containsKey(sum - 1)) {
////////////////////////////////                    ans = Math.max(ans, map.get(sum - 1));
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            if (!map.containsKey(sum)) {
////////////////////////////////                map.put(sum, i);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class NumArray {
////////////////////////////////
////////////////////////////////        int[] sum;
////////////////////////////////
////////////////////////////////        public NumArray(int[] nums) {
////////////////////////////////            sum = new int[nums.length + 1];
////////////////////////////////            sum[0] = 0;
////////////////////////////////            for (int i = 0; i < nums.length; i++) {
////////////////////////////////                sum[i + 1] = sum[i] + nums[i];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int sumRange(int left, int right) {
////////////////////////////////            return sum[right + 1] - sum[left - 1];
////////////////////////////////        }
////////////////////////////////    }
//////////////////////////////
//////////////////////////////
////////////////////////////////
////////////////////////////////
////////////////////////////////    public class ListNode {
////////////////////////////////        int val;
////////////////////////////////        ListNode next = null;
////////////////////////////////
////////////////////////////////        ListNode(int val) {
////////////////////////////////            this.val = val;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class Node {
////////////////////////////////        int val;
////////////////////////////////        Node next;
////////////////////////////////        Node random;
////////////////////////////////
////////////////////////////////        public Node(int val) {
////////////////////////////////            this.val = val;
////////////////////////////////            this.next = null;
////////////////////////////////            this.random = null;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class RandomizedCollection {
////////////////////////////////
////////////////////////////////        HashMap<Integer, HashSet<Integer>> map;
////////////////////////////////
////////////////////////////////        ArrayList<Integer> arr;
////////////////////////////////
////////////////////////////////        public RandomizedCollection() {
////////////////////////////////            map = new HashMap<>();
////////////////////////////////            arr = new ArrayList<>();
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public boolean insert(int val) {
////////////////////////////////            HashSet<Integer> set = map.getOrDefault(val, new HashSet<>());
////////////////////////////////            set.add(arr.size());
////////////////////////////////            map.put(val, set);
////////////////////////////////            arr.add(val);
////////////////////////////////            return set.size() == 1;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public boolean remove(int val) {
////////////////////////////////            if (!map.containsKey(val)) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            HashSet<Integer> valSet = map.get(val);
////////////////////////////////            Integer valIndex = valSet.iterator().next();
////////////////////////////////            Integer endValue = arr.get(arr.size() - 1);
////////////////////////////////            if (endValue == val) {
////////////////////////////////                valSet.remove(arr.size() - 1);
////////////////////////////////            } else {
////////////////////////////////                HashSet<Integer> endValSet = map.get(endValue);
////////////////////////////////                endValSet.add(valIndex);
////////////////////////////////                arr.set(valIndex, endValue);
////////////////////////////////                valSet.remove(valIndex);
////////////////////////////////                endValSet.remove(arr.size() - 1);
////////////////////////////////            }
////////////////////////////////            arr.remove(arr.size() - 1);
////////////////////////////////            if (valSet.isEmpty()) {
////////////////////////////////                map.remove(val);
////////////////////////////////            }
////////////////////////////////            return true;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int getRandom() {
////////////////////////////////            return arr.get((int) (Math.random() * (arr.size())));
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    class RandomizedSet {
////////////////////////////////        HashMap<Integer, Integer> map;
////////////////////////////////
////////////////////////////////        ArrayList<Integer> arr;
////////////////////////////////
////////////////////////////////        public RandomizedSet() {
////////////////////////////////            map = new HashMap<>();
////////////////////////////////            arr = new ArrayList<>();
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public boolean insert(int val) {
////////////////////////////////            if (map.containsKey(val)) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            map.put(val, arr.size());
////////////////////////////////            arr.add(val);
////////////////////////////////            return true;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public boolean remove(int val) {
////////////////////////////////            if (!map.containsKey(val)) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            Integer valIndex = map.get(val);
////////////////////////////////            Integer endValue = arr.get(arr.size() - 1);
////////////////////////////////            map.remove(endValue);
////////////////////////////////            map.put(endValue, valIndex);
////////////////////////////////            map.remove(val);
////////////////////////////////            arr.remove(arr.size() - 1);
////////////////////////////////            return true;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int getRandom() {
////////////////////////////////            return arr.get((int) Math.random() * (arr.size() - 1));
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class AllOne {
////////////////////////////////
////////////////////////////////        class Bucket {
////////////////////////////////            public HashSet<String> set;
////////////////////////////////            public int cnt;
////////////////////////////////            public Bucket last;
////////////////////////////////            public Bucket next;
////////////////////////////////
////////////////////////////////            public Bucket(String s, int c) {
////////////////////////////////                set = new HashSet<>();
////////////////////////////////                set.add(s);
////////////////////////////////                cnt = c;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private void insert(Bucket cur, Bucket pos) {
////////////////////////////////            cur.next.last = pos;
////////////////////////////////            pos.next = cur.next;
////////////////////////////////            cur.next = pos;
////////////////////////////////            pos.last = cur;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private void remove(Bucket cur) {
////////////////////////////////            cur.last.next = cur.next;
////////////////////////////////            cur.next.last = cur.last;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        Bucket head;
////////////////////////////////
////////////////////////////////        Bucket tail;
////////////////////////////////
////////////////////////////////        HashMap<String, Bucket> map;
////////////////////////////////
////////////////////////////////        public AllOne() {
////////////////////////////////            head = new Bucket("", 0);
////////////////////////////////            tail = new Bucket("", Integer.MAX_VALUE);
////////////////////////////////            head.next = tail;
////////////////////////////////            tail.last = head;
////////////////////////////////            map = new HashMap<>();
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public void inc(String key) {
////////////////////////////////            if (!map.containsKey(key)) {
////////////////////////////////                if (head.next.cnt == 1) {
////////////////////////////////                    map.put(key, head.next);
////////////////////////////////                    head.next.set.add(key);
////////////////////////////////                } else {
////////////////////////////////                    Bucket newBucket = new Bucket(key, 1);
////////////////////////////////                    map.put(key, newBucket);
////////////////////////////////                    insert(head, newBucket);
////////////////////////////////                }
////////////////////////////////            } else {
////////////////////////////////                Bucket bucket = map.get(key);
////////////////////////////////                if (bucket.next.cnt == bucket.cnt + 1) {
////////////////////////////////                    map.put(key, bucket.next);
////////////////////////////////                    bucket.next.set.add(key);
////////////////////////////////                } else {
////////////////////////////////                    Bucket newBucket = new Bucket(key, bucket.cnt + 1);
////////////////////////////////                    map.put(key, newBucket);
////////////////////////////////                    insert(bucket, newBucket);
////////////////////////////////                }
////////////////////////////////                bucket.set.remove(key);
////////////////////////////////                if (bucket.set.isEmpty()) {
////////////////////////////////                    remove(bucket);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public void dec(String key) {
////////////////////////////////            Bucket bucket = map.get(key);
////////////////////////////////            if (bucket.cnt == 1) {
////////////////////////////////                map.remove(key);
////////////////////////////////            } else {
////////////////////////////////                if (bucket.last.cnt == bucket.cnt - 1) {
////////////////////////////////                    map.put(key, bucket.last);
////////////////////////////////                    bucket.last.set.add(key);
////////////////////////////////                } else {
////////////////////////////////                    Bucket newBucket = new Bucket(key, bucket.cnt - 1);
////////////////////////////////                    map.put(key, newBucket);
////////////////////////////////                    insert(bucket.last, newBucket);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            bucket.set.remove(key);
////////////////////////////////            if (bucket.set.isEmpty()) {
////////////////////////////////                remove(bucket);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public String getMaxKey() {
////////////////////////////////            return tail.last.set.iterator().next();
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public String getMinKey() {
////////////////////////////////            return head.next.set.iterator().next();
////////////////////////////////        }
////////////////////////////////
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class FreqStack {
////////////////////////////////
////////////////////////////////        int maxCnt;
////////////////////////////////
////////////////////////////////        HashMap<Integer, ArrayList<Integer>> cntList;
////////////////////////////////
////////////////////////////////        HashMap<Integer, Integer> cntValue;
////////////////////////////////
////////////////////////////////        public FreqStack() {
////////////////////////////////            cntList = new HashMap<>();
////////////////////////////////            cntValue = new HashMap<>();
////////////////////////////////            maxCnt = 0;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public void push(int val) {
////////////////////////////////            cntValue.put(val, cntValue.getOrDefault(val, 0) + 1);
////////////////////////////////            int curTopTimes = cntValue.get(val);
////////////////////////////////            if (!cntList.containsKey(curTopTimes)) {
////////////////////////////////                cntList.put(curTopTimes, new ArrayList<>());
////////////////////////////////            }
////////////////////////////////            ArrayList<Integer> list = cntList.get(curTopTimes);
////////////////////////////////            list.add(val);
////////////////////////////////            maxCnt = Math.max(curTopTimes, maxCnt);
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int pop() {
////////////////////////////////            ArrayList<Integer> list = cntList.get(maxCnt);
////////////////////////////////            Integer ans = list.remove(list.size() - 1);
////////////////////////////////            if (list.isEmpty()) {
////////////////////////////////                cntList.remove(maxCnt--);
////////////////////////////////            }
////////////////////////////////            Integer times = cntValue.get(ans);
////////////////////////////////            if (times == 0) {
////////////////////////////////                cntValue.remove(ans);
////////////////////////////////            } else {
////////////////////////////////                cntValue.put(ans, times - 1);
////////////////////////////////            }
////////////////////////////////            return ans;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class KthLargest {
////////////////////////////////
////////////////////////////////        PriorityQueue<Integer> pq;
////////////////////////////////
////////////////////////////////        int big_k;
////////////////////////////////
////////////////////////////////        public KthLargest(int k, int[] nums) {
////////////////////////////////            big_k = k;
////////////////////////////////            pq = new PriorityQueue<>((a, b) -> (a - b));
////////////////////////////////            for (int num : nums) {
////////////////////////////////                pq.add(num);
////////////////////////////////                if (pq.size() > big_k) {
////////////////////////////////                    pq.poll();
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int add(int val) {
////////////////////////////////            pq.add(val);
////////////////////////////////            if (pq.size() > big_k)
////////////////////////////////                pq.poll();
////////////////////////////////            return pq.peek();
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class MedianFinder {
////////////////////////////////        Queue<Integer> minHeap, maxHeap;
////////////////////////////////
////////////////////////////////        public MedianFinder() {
////////////////////////////////            minHeap = new PriorityQueue<>((x, y) -> (x - y));
////////////////////////////////            maxHeap = new PriorityQueue<>((x, y) -> (y - x));
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public void addNum(int num) {
////////////////////////////////            if (maxHeap.isEmpty() || num <= maxHeap.peek()) {
////////////////////////////////                maxHeap.add(num);
////////////////////////////////            } else {
////////////////////////////////                minHeap.add(num);
////////////////////////////////            }
////////////////////////////////            balance();
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private void balance() {
////////////////////////////////            if (Math.abs(minHeap.size() - maxHeap.size()) == 2) {
////////////////////////////////                if (minHeap.size() > maxHeap.size()) {
////////////////////////////////                    maxHeap.add(minHeap.poll());
////////////////////////////////                } else {
////////////////////////////////                    minHeap.add(maxHeap.poll());
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public double findMedian() {
////////////////////////////////            if (maxHeap.size() == minHeap.size()) {
////////////////////////////////                return (maxHeap.peek() + minHeap.peek()) / 2.0;
////////////////////////////////            }
////////////////////////////////            return maxHeap.size() > minHeap.size() ? maxHeap.peek() : minHeap.peek();
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public class TreeNode {
////////////////////////////////        int val;
////////////////////////////////        TreeNode left;
////////////////////////////////        TreeNode right;
////////////////////////////////
////////////////////////////////        TreeNode() {
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        TreeNode(int val) {
////////////////////////////////            this.val = val;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        TreeNode(int val, TreeNode left, TreeNode right) {
////////////////////////////////            this.val = val;
////////////////////////////////            this.left = left;
////////////////////////////////            this.right = right;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public TreeNode[] st = new TreeNode[MAX_N];
////////////////////////////////
////////////////////////////////    public static int yes;
////////////////////////////////
////////////////////////////////    public static int no;
////////////////////////////////
////////////////////////////////    public int rob(TreeNode root) {
////////////////////////////////        f(root);
////////////////////////////////        return Math.max(yes, no);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void f(TreeNode root) {
////////////////////////////////        if (root == null) {
////////////////////////////////            yes = 0;
////////////////////////////////            no = 0;
////////////////////////////////        }
////////////////////////////////        int y = root.val;
////////////////////////////////        int n = 0;
////////////////////////////////        f(root.left);
////////////////////////////////        y += no;
////////////////////////////////        n += Math.max(yes, no);
////////////////////////////////        f(root.right);
////////////////////////////////        y += no;
////////////////////////////////        n += Math.max(yes, no);
////////////////////////////////        yes = y;
////////////////////////////////        no = n;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public String[] generatePermutation(String s) {
////////////////////////////////        char[] charArray = s.toCharArray();
////////////////////////////////        Set<String> set = new HashSet<>();
////////////////////////////////        f(charArray, 0, new char[charArray.length], 0, set);
////////////////////////////////        String[] ret = new String[set.size()];
////////////////////////////////        int index = 0;
////////////////////////////////        for (String string : set) {
////////////////////////////////            ret[index++] = string;
////////////////////////////////        }
////////////////////////////////        return ret;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    private void f(char[] charArray, int i, StringBuilder sb, Set<String> set) {
////////////////////////////////        if (i == charArray.length) {
////////////////////////////////            set.add(sb.toString());
////////////////////////////////        } else {
////////////////////////////////            sb.append(charArray[i]);
////////////////////////////////            f(charArray, i + 1, sb, set);
////////////////////////////////            sb.deleteCharAt(sb.length() - 1);
////////////////////////////////            f(charArray, i, sb, set);
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void f(char[] charArray, int i, char[] path, int size, Set<String> set) {
////////////////////////////////        if (i == charArray.length) {
////////////////////////////////            set.add(String.valueOf(path, 0, size));
////////////////////////////////        } else {
////////////////////////////////            path[size] = charArray[i];
////////////////////////////////            f(charArray, i + 1, path, size + 1, set);
////////////////////////////////            f(charArray, i + 1, path, size, set);
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public TreeNode trimBST(TreeNode root, int low, int high) {
////////////////////////////////        if (root == null)
////////////////////////////////            return null;
////////////////////////////////        if (root.val < low)
////////////////////////////////            return trimBST(root.right, low, high);
////////////////////////////////        if (root.val > high)
////////////////////////////////            return trimBST(root.left, low, high);
////////////////////////////////        root.left = trimBST(root.left, low, high);
////////////////////////////////        root.right = trimBST(root.right, low, high);
////////////////////////////////        return root;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public static long min, max;
////////////////////////////////
////////////////////////////////    public boolean isValidBST(TreeNode root) {
////////////////////////////////        if (root == null) {
////////////////////////////////            min = Long.MAX_VALUE;
////////////////////////////////            max = Long.MIN_VALUE;
////////////////////////////////            return true;
////////////////////////////////        }
////////////////////////////////        boolean lret = isValidBST(root.left);
////////////////////////////////        long lmin = min;
////////////////////////////////        long lmax = max;
////////////////////////////////        boolean rret = isValidBST(root.right);
////////////////////////////////        long rmin = min;
////////////////////////////////        long rmax = max;
////////////////////////////////        min = Math.min(Math.min(lmin, rmin), root.val);
////////////////////////////////        max = Math.max(Math.max(lmax, rmax), root.val);
////////////////////////////////        return lret && rret && root.val > lmax && root.val < rmin;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static boolean balance;
////////////////////////////////
////////////////////////////////    public boolean isBalanced(TreeNode root) {
////////////////////////////////        balance = true;
////////////////////////////////        hight(root);
////////////////////////////////        return balance;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int hight(TreeNode root) {
////////////////////////////////        if (!balance || root == null) return 0;
////////////////////////////////        int lh = hight(root.left);
////////////////////////////////        int rh = hight(root.right);
////////////////////////////////        if (Math.abs(lh - rh) > 1) {
////////////////////////////////            balance = false;
////////////////////////////////        }
////////////////////////////////        return Math.max(lh, rh) + 1;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
////////////////////////////////        if (root == null) return null;
////////////////////////////////        List<List<Integer>> ans = new ArrayList<>();
////////////////////////////////        List<Integer> path = new ArrayList<>();
////////////////////////////////        backGround(root, targetSum, 0, path, ans);
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void backGround(TreeNode root, int targetSum, int curSum, List<Integer> path, List<List<Integer>> ans) {
////////////////////////////////        if (root.left == null && root.right == null) {
////////////////////////////////            if (curSum + root.val == targetSum) {
////////////////////////////////                path.add(root.val);
////////////////////////////////                copyPath(path, ans);
////////////////////////////////                path.remove(path.size() - 1);
////////////////////////////////            }
////////////////////////////////        } else {
////////////////////////////////            path.add(root.val);
////////////////////////////////            if (root.left != null)
////////////////////////////////                backGround(root.left, targetSum, curSum + root.val, path, ans);
////////////////////////////////            if (root.right != null)
////////////////////////////////                backGround(root.right, targetSum, curSum + root.val, path, ans);
////////////////////////////////            path.remove(path.size() - 1);
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void copyPath(List<Integer> path, List<List<Integer>> ans) {
////////////////////////////////        List<Integer> tmp = new ArrayList<>();
////////////////////////////////        for (Integer integer : path) {
////////////////////////////////            tmp.add(integer);
////////////////////////////////        }
////////////////////////////////        ans.add(tmp);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public TreeNode buildTree(int[] inorder, int[] postorder) {
////////////////////////////////        if (inorder.length == 0 || postorder.length == 0 || inorder.length != postorder.length)
////////////////////////////////            return null;
////////////////////////////////
////////////////////////////////        HashMap<Integer, Integer> map = new HashMap<>(inorder.length);
////////////////////////////////        for (int i = 0; i < inorder.length; i++) {
////////////////////////////////            map.put(inorder[i], i);
////////////////////////////////        }
////////////////////////////////        // map.forEach((k, v) -> System.out.println(k + " " + v));
////////////////////////////////        return build(postorder, 0, postorder.length, inorder, 0, inorder.length, map);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private TreeNode build(int[] post, int l1, int r1, int[] in, int l2, int r2, HashMap<Integer, Integer> map) {
////////////////////////////////        if (l1 == r1)
////////////////////////////////            return null;
////////////////////////////////
////////////////////////////////        int k = map.get(post[r1 - 1]) - l2;
////////////////////////////////        TreeNode left = build(post, l1, l1 + k, in, l2, l2 + k, map);
////////////////////////////////        TreeNode right = build(post, l1 + k, r1 - 1, in, l2 + k + 1, r2, map);
////////////////////////////////        return new TreeNode(post[r1 - 1], left, right);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private TreeNode dfs(int[] postorder, int l1, int r1, int[] inorder, int l2, int r2,
////////////////////////////////                         Map<Integer, Integer> index) {
////////////////////////////////        if (l1 == r1) { // 空节点
////////////////////////////////            return null;
////////////////////////////////        }
////////////////////////////////        int leftSize = index.get(postorder[r1 - 1]) - l2; // 左子树的大小
////////////////////////////////        TreeNode left = dfs(postorder, l1, l1 + leftSize, inorder, l2, l2 + leftSize, index);
////////////////////////////////        TreeNode right = dfs(postorder, l1 + leftSize, r1 - 1, inorder, l2 + leftSize + 1, r2, index);
////////////////////////////////        return new TreeNode(postorder[r1 - 1], left, right);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    // Encodes a tree to a single string.
////////////////////////////////    public String serialize1(TreeNode root) {
////////////////////////////////        StringBuilder sb = new StringBuilder();
////////////////////////////////        f(sb, root);
////////////////////////////////        return sb.toString();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void f(StringBuilder sb, TreeNode root) {
////////////////////////////////        if (root == null) {
////////////////////////////////            sb.append("#,");
////////////////////////////////            return;
////////////////////////////////        }
////////////////////////////////        sb.append(root.val + ",");
////////////////////////////////        f(sb, root.left);
////////////////////////////////        f(sb, root.right);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////// public int cnt;
////////////////////////////////
////////////////////////////////    // Decodes your encoded data to tree.
////////////////////////////////    public TreeNode deserialize1(String data) {
////////////////////////////////        String[] values = data.split(",");
////////////////////////////////        cnt = 0;
////////////////////////////////        return g(values);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private TreeNode g(String[] values) {
////////////////////////////////        if (values[cnt].equals("#")) {
////////////////////////////////            cnt++;
////////////////////////////////            return null;
////////////////////////////////        }
////////////////////////////////        TreeNode root = new TreeNode(Integer.parseInt(values[cnt++]));
////////////////////////////////        root.left = g(values);
////////////////////////////////        root.right = g(values);
////////////////////////////////        return root;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class Solution {
////////////////////////////////        public boolean isSubtree(TreeNode root, TreeNode subRoot) {
////////////////////////////////            if (root == null && subRoot == null) return true;
////////////////////////////////            if (root == null && subRoot != null) return false;
////////////////////////////////            if (root != null && subRoot == null) return true;
////////////////////////////////            ArrayList<String> s1 = new ArrayList<>();
////////////////////////////////            ArrayList<String> s2 = new ArrayList<>();
////////////////////////////////            serialize(s1, root);
////////////////////////////////            serialize(s2, subRoot);
////////////////////////////////            return kmp(s1, s2) != -1;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private int kmp(ArrayList<String> s1, ArrayList<String> s2) {
////////////////////////////////            int n = s1.size();
////////////////////////////////            int m = s2.size();
////////////////////////////////            int[] next = getNext(s2, m);
////////////////////////////////            int x = 0;
////////////////////////////////            int y = 0;
////////////////////////////////            while (x < n && y < m) {
////////////////////////////////                if (isSame(s1.get(x), s2.get(y))) {
////////////////////////////////                    x++;
////////////////////////////////                    y++;
////////////////////////////////                } else if (y > 0) {
////////////////////////////////                    y = next[y];
////////////////////////////////                } else {
////////////////////////////////                    x++;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            return y == m ? x - y : -1;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private int[] getNext(ArrayList<String> s2, int m) {
////////////////////////////////            if (m == 0)
////////////////////////////////                return new int[]{-1};
////////////////////////////////            int[] next = new int[m];
////////////////////////////////            next[0] = -1;
////////////////////////////////            next[1] = 0;
////////////////////////////////            int i = 2;
////////////////////////////////            int cn = 0;
////////////////////////////////            while (i < m) {
////////////////////////////////                if (isSame(s2.get(i - 1), s2.get(cn))) {
////////////////////////////////                    next[i++] = ++cn;
////////////////////////////////                } else if (cn > 0) {
////////////////////////////////                    cn = next[cn];
////////////////////////////////                } else {
////////////////////////////////                    next[i++] = 0;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            return next;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private boolean isSame(String s1, String s2) {
////////////////////////////////            if (s1 == null && s2 == null) return true;
////////////////////////////////            if (s1 != null && s2 != null) return s1.equals(s2);
////////////////////////////////            return false;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private void serialize(ArrayList<String> s, TreeNode root) {
////////////////////////////////            if (root == null) {
////////////////////////////////                s.add(null);
////////////////////////////////                return;
////////////////////////////////            }
////////////////////////////////            s.add(String.valueOf(root.val));
////////////////////////////////            serialize(s, root.left);
////////////////////////////////            serialize(s, root.right);
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public int MAX_N = 100005;
////////////////////////////////    public int[][] tree = new int[MAX_N][26];
////////////////////////////////
////////////////////////////////    public int[] pass = new int[MAX_N];
////////////////////////////////
////////////////////////////////    public int[] end = new int[MAX_N];
////////////////////////////////
////////////////////////////////    public int cnt;
////////////////////////////////
////////////////////////////////    public void build() {
////////////////////////////////        cnt = 1;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public void insert(String word) {
////////////////////////////////        int cur = 1;
////////////////////////////////        pass[cur]++;
////////////////////////////////        for (int i = 0; i < word.length(); i++) {
////////////////////////////////            int index = word.charAt(i) - 'a';
////////////////////////////////            if (tree[cur][index] == 0) {
////////////////////////////////                tree[cur][index] = ++cnt;
////////////////////////////////            }
////////////////////////////////            cur = tree[cur][index];
////////////////////////////////            pass[cur]++;
////////////////////////////////        }
////////////////////////////////        end[cur]++;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class Solution {
////////////////////////////////        public List<String> findWords(char[][] board, String[] words) {
////////////////////////////////            build(words);
////////////////////////////////            List<String> ans = new ArrayList<>();
////////////////////////////////            for (int i = 0; i < board.length; i++) {
////////////////////////////////                for (int j = 0; j < board[i].length; j++) {
////////////////////////////////                    dfs(board, i, j, 1, ans);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            clear();
////////////////////////////////            return ans;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private int dfs(char[][] board, int i, int j, int t, List<String> ans) {
////////////////////////////////            if (i < 0 || j < 0 || i >= board.length || j >= board[0].length || board[i][j] == '0') {
////////////////////////////////                return 0;
////////////////////////////////            }
////////////////////////////////            char tmp = board[i][j];
////////////////////////////////            int road = tmp - 'a';
////////////////////////////////            t = tree[t][road];
////////////////////////////////            if (pass[t] == 0) {
////////////////////////////////                return 0;
////////////////////////////////            }
////////////////////////////////            int count = 0;
////////////////////////////////            if (end[t] != null) {
////////////////////////////////                count++;
////////////////////////////////                ans.add(end[t]);
////////////////////////////////                end[t] = null;
////////////////////////////////            }
////////////////////////////////            board[i][j] = '0';
////////////////////////////////            count += dfs(board, i - 1, j, t, ans);
////////////////////////////////            count += dfs(board, i + 1, j, t, ans);
////////////////////////////////            count += dfs(board, i, j - 1, t, ans);
////////////////////////////////            count += dfs(board, i, j + 1, t, ans);
////////////////////////////////            board[i][j] = tmp;
////////////////////////////////            pass[t] -= count;
////////////////////////////////            return count;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////
////////////////////////////////        public static int cnt;
////////////////////////////////
////////////////////////////////        public static int MAX_N = 150005;
////////////////////////////////        public static int[][] tree = new int[MAX_N][26];
////////////////////////////////
////////////////////////////////        public static int[] pass = new int[MAX_N];
////////////////////////////////
////////////////////////////////        public static String end[] = new String[MAX_N];
////////////////////////////////
////////////////////////////////        public static void insert(String word) {
////////////////////////////////            int cur = 1;
////////////////////////////////            pass[cur]++;
////////////////////////////////            for (int i = 0; i < word.length(); i++) {
////////////////////////////////                int index = word.charAt(i) - 'a';
////////////////////////////////                if (tree[cur][index] == 0) {
////////////////////////////////                    tree[cur][index] = ++cnt;
////////////////////////////////                }
////////////////////////////////                cur = tree[cur][index];
////////////////////////////////                pass[cur]++;
////////////////////////////////            }
////////////////////////////////            end[cur] = word;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static void build(String[] words) {
////////////////////////////////            cnt = 1;
////////////////////////////////            for (String word : words) {
////////////////////////////////                insert(word);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static void clear() {
////////////////////////////////            for (int i = 0; i <= cnt; i++) {
////////////////////////////////                Arrays.fill(tree[i], 0);
////////////////////////////////                pass[i] = 0;
////////////////////////////////                end[i] = null;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class countConsistentKeys {
////////////////////////////////
////////////////////////////////        public static int MAX_N = 100005;
////////////////////////////////
////////////////////////////////        public static int[][] tree = new int[MAX_N][12];
////////////////////////////////
////////////////////////////////        public static int[] pass = new int[MAX_N];
////////////////////////////////
////////////////////////////////        public static int cnt;
////////////////////////////////
////////////////////////////////        public static void build() {
////////////////////////////////            cnt = 1;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        private static int getPath(char c) {
////////////////////////////////            if (c == '#') {
////////////////////////////////                return 10;
////////////////////////////////            } else if (c == '-') {
////////////////////////////////                return 11;
////////////////////////////////            } else {
////////////////////////////////                return c - '0';
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static void insert(String word) {
////////////////////////////////            int cur = 1;
////////////////////////////////            pass[cur]++;
////////////////////////////////            for (int i = 0; i < word.length(); i++) {
////////////////////////////////                int index = getPath(word.charAt(i));
////////////////////////////////                if (tree[cur][index] == 0) {
////////////////////////////////                    tree[cur][index] = ++cnt;
////////////////////////////////                }
////////////////////////////////                cur = tree[cur][index];
////////////////////////////////                pass[cur]++;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static int startWith(String prefix) {
////////////////////////////////            int cur = 1;
////////////////////////////////            for (int i = 0; i < prefix.length(); i++) {
////////////////////////////////                int index = getPath(prefix.charAt(i));
////////////////////////////////                if (tree[cur][index] == 0) {
////////////////////////////////                    return 0;
////////////////////////////////                }
////////////////////////////////                cur = tree[cur][index];
////////////////////////////////            }
////////////////////////////////            return pass[cur];
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static void clear() {
////////////////////////////////            for (int i = 0; i <= cnt; i++) {
////////////////////////////////                Arrays.fill(tree[i], 0);
////////////////////////////////                pass[i] = 0;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int[] countConsistentKeys(int[][] b, int[][] a) {
////////////////////////////////            StringBuilder sb = new StringBuilder();
////////////////////////////////            for (int[] nums : a) {
////////////////////////////////                sb.setLength(0);
////////////////////////////////                for (int i = 1; i < nums.length; i++) {
////////////////////////////////                    sb.append(nums[i] - nums[i - 1]);
////////////////////////////////                    sb.append("#");
////////////////////////////////                }
////////////////////////////////                insert(sb.toString());
////////////////////////////////            }
////////////////////////////////            int[] ans = new int[b.length];
////////////////////////////////            for (int i = 0; i < b.length; i++) {
////////////////////////////////                sb.setLength(0);
////////////////////////////////                for (int j = 1; j < b[i].length; j++) {
////////////////////////////////                    sb.append(b[i][j] - b[i][j - 1]);
////////////////////////////////                }
////////////////////////////////                ans[i] = startWith(sb.toString());
////////////////////////////////            }
////////////////////////////////            return ans;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class KMP {
////////////////////////////////
////////////////////////////////        public int strStr(String haystack, String needle) {
////////////////////////////////            return kmp(haystack.toCharArray(), needle.toCharArray());
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int kmp(char[] s1, char[] s2) {
////////////////////////////////            int n = s1.length;
////////////////////////////////            int m = s2.length;
////////////////////////////////            int[] next = getNext(s2, m);
////////////////////////////////            int x = 0;
////////////////////////////////            int y = 0;
////////////////////////////////            while (x < n && y < m) {
////////////////////////////////                if (s1[x] == s2[y]) {
////////////////////////////////                    x++;
////////////////////////////////                    y++;
////////////////////////////////                } else if (y > 0) {
////////////////////////////////                    y = next[y];
////////////////////////////////                } else {
////////////////////////////////                    x++;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            return y == m ? x - y : -1;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int[] getNext(char[] s, int m) {
////////////////////////////////            if (m == 1) return new int[]{-1};
////////////////////////////////            int[] next = new int[m];
////////////////////////////////            next[0] = -1;
////////////////////////////////            next[1] = 0;
////////////////////////////////            int i = 2;
////////////////////////////////            int cn = 0;
////////////////////////////////            while (i < m) {
////////////////////////////////                if (s[i - 1] == s[cn]) {
////////////////////////////////                    next[i++] = ++cn;
////////////////////////////////                } else if (cn > 0) {
////////////////////////////////                    cn = next[cn];
////////////////////////////////                } else {
////////////////////////////////                    next[i++] = 0;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            return next;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int search(String word) {
////////////////////////////////        int cur = 1;
////////////////////////////////        for (int i = 0; i < word.length(); i++) {
////////////////////////////////            int path = word.charAt(i) - 'a';
////////////////////////////////            if (tree[cur][path] == 0) {
////////////////////////////////                return 0;
////////////////////////////////            }
////////////////////////////////            cur = tree[cur][path];
////////////////////////////////        }
////////////////////////////////        return end[cur];
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public boolean startsWith(String prefix) {
////////////////////////////////        int cur = 0;
////////////////////////////////        for (int i = 0; i < prefix.length(); i++) {
////////////////////////////////            int index = prefix.charAt(i) - 'a';
////////////////////////////////            if (tree[cur][index] == 0) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            cur = tree[cur][index];
////////////////////////////////        }
////////////////////////////////        return true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public void clear() {
////////////////////////////////        for (int i = 0; i < cnt; i++) {
////////////////////////////////            Arrays.fill(tree[i], 0);
////////////////////////////////            pass[i] = 0;
////////////////////////////////            end[i] = 0;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int[] countConsistentKeys(int[][] b, int[][] a) {
////////////////////////////////        build();
////////////////////////////////        StringBuilder sb = new StringBuilder();
////////////////////////////////        for (int i = 0; i < a.length; i++) {
////////////////////////////////            sb.setLength(0);
////////////////////////////////            for (int j = 0; j < a[i].length; j++) {
////////////////////////////////                sb.append(String.valueOf(a[i][j] - a[i][j - 1]) + "#");
////////////////////////////////            }
////////////////////////////////            insert(sb.toString());
////////////////////////////////        }
////////////////////////////////        int[] ans = new int[b.length];
////////////////////////////////        for (int i = 0; i < b.length; i++) {
////////////////////////////////            sb.setLength(0);
////////////////////////////////            int[] nums = b[i];
////////////////////////////////            for (int j = 1; j < nums.length; j++) {
////////////////////////////////                sb.append(String.valueOf(nums[j] - nums[j - 1]) + "#");
////////////////////////////////            }
////////////////////////////////            ans[i] = search(sb.toString());
////////////////////////////////        }
////////////////////////////////        clear();
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static int superpalindromesInRange(String left, String right) {
////////////////////////////////        long l = Long.valueOf(left);
////////////////////////////////        long r = Long.valueOf(right);
////////////////////////////////        long limit = (long) Math.sqrt((double) r);
////////////////////////////////        long seed = 1;
////////////////////////////////        long num = 0;
////////////////////////////////        int ans = 0;
////////////////////////////////        do {
////////////////////////////////            num = evenEnlarge(seed);
////////////////////////////////            if (check(num * num, l, r)) {
////////////////////////////////                ans++;
////////////////////////////////            }
////////////////////////////////            num = oddEnlarge(seed);
////////////////////////////////            if (check(num * num, l, r)) {
////////////////////////////////                ans++;
////////////////////////////////            }
////////////////////////////////            seed++;
////////////////////////////////        } while (num < limit);
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static long evenEnlarge(long seed) {
////////////////////////////////        long ans = seed;
////////////////////////////////        while (seed != 0) {
////////////////////////////////            ans = ans * 10 + seed % 10;
////////////////////////////////            seed /= 10;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static long oddEnlarge(long seed) {
////////////////////////////////        long ans = seed;
////////////////////////////////        seed /= 10;
////////////////////////////////        while (seed != 0) {
////////////////////////////////            ans = ans * 10 + seed % 10;
////////////////////////////////            seed /= 10;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static boolean check(long ans, long l, long r) {
////////////////////////////////        return ans >= l && ans <= r && isPalindrome(ans);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static boolean isPalindrome(long num) {
////////////////////////////////        long offset = 1;
////////////////////////////////        while (num / offset >= 10) {
////////////////////////////////            offset *= 10;
////////////////////////////////        }
////////////////////////////////        while (num != 0) {
////////////////////////////////            if (num / offset != num % 10) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            num = (num % offset) / 10;
////////////////////////////////            offset /= 100;
////////////////////////////////        }
////////////////////////////////        return true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public boolean isPalindrome(int x) {
////////////////////////////////        if (x < 0)
////////////////////////////////            return false;
////////////////////////////////        int offset = 1;
////////////////////////////////        while (x / offset >= 10) {
////////////////////////////////            offset *= 10;
////////////////////////////////        }
////////////////////////////////        while (x > 0) {
////////////////////////////////            if (x / offset != x % 10) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            x = (x % offset) / 10;
////////////////////////////////            offset /= 100;
////////////////////////////////        }
////////////////////////////////        return true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int totalNQueens(int n) {
////////////////////////////////        if (n <= 0) return 0;
////////////////////////////////        return f1(0, new int[n], n);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int f1(int i, int[] path, int n) {
////////////////////////////////        if (i == n) return 1;
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int j = 0; j < n; j++) {
////////////////////////////////            if (check(path, i, j)) {
////////////////////////////////                path[i] = j;
////////////////////////////////                ans += f1(i + 1, path, n);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int superEggDrop(int k, int n) {
////////////////////////////////        int[][] dp = new int[n + 1][k + 1];
////////////////////////////////        for (int i = 1; ; i++) {
////////////////////////////////            for (int j = 1; j <= k; j++) {
////////////////////////////////                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] + 1;
////////////////////////////////            }
////////////////////////////////            if (dp[i][k] >= n) {
////////////////////////////////                return i;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int totalNQueens2(int n) {
////////////////////////////////        int limit = (1 << n) - 1;
////////////////////////////////        return f(limit, 0, 0, 0);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int f(int limit, int col, int left, int right) {
////////////////////////////////        if (col == limit) {
////////////////////////////////            return 1;
////////////////////////////////        }
////////////////////////////////        int ban = col | left | right;
////////////////////////////////        int candidate = limit & (~ban);
////////////////////////////////        int place = 0;
////////////////////////////////        int ans = 0;
////////////////////////////////        while (candidate != 0) {
////////////////////////////////            place = candidate & (-candidate);
////////////////////////////////            candidate ^= place;
////////////////////////////////            ans += f(limit, col | place, (left | place) >> 1, (right | place) << 1);
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public String solve(String s, String t) {
////////////////////////////////        BigInteger a = new BigInteger(s);
////////////////////////////////        a = a.add(new BigInteger(t));
////////////////////////////////        return a.toString();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private boolean check(int[] path, int i, int j) {
////////////////////////////////        for (int k = 0; k < i; k++) {
////////////////////////////////            if (j == path[k] || Math.abs(i - k) == Math.abs(j - path[k])) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int where;
////////////////////////////////
////////////////////////////////    public String countOfAtoms(String formula) {
////////////////////////////////        where = 0;
////////////////////////////////        TreeMap<String, Integer> map = g(formula.toCharArray(), 0);
////////////////////////////////        StringBuilder sb = new StringBuilder();
////////////////////////////////        for (String key : map.keySet()) {
////////////////////////////////            sb.append(key);
////////////////////////////////            int count = map.get(key);
////////////////////////////////            if (count > 1) {
////////////////////////////////                sb.append(count);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return sb.toString();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private TreeMap<String, Integer> g(char[] s, int i) {
////////////////////////////////        TreeMap<String, Integer> ans = new TreeMap<>();
////////////////////////////////        StringBuilder name = new StringBuilder();
////////////////////////////////        TreeMap<String, Integer> pre = null;
////////////////////////////////        int cnt = 0;
////////////////////////////////        while (i < s.length && s[i] != ')') {
////////////////////////////////            if (s[i] >= 'A' && s[i] <= 'Z' || s[i] == '(') {
////////////////////////////////                fillAns(ans, name, pre, cnt);
////////////////////////////////                name.setLength(0);
////////////////////////////////                pre = null;
////////////////////////////////                cnt = 0;
////////////////////////////////                if (s[i] >= 'A' && s[i] <= 'Z') {
////////////////////////////////                    name.append(s[i++]);
////////////////////////////////                } else {
////////////////////////////////                    pre = g(s, i + 1);
////////////////////////////////                    i = where + 1;
////////////////////////////////                }
////////////////////////////////            } else if (s[i] >= 'a' && s[i] <= 'z') {
////////////////////////////////                name.append(s[i++]);
////////////////////////////////            } else {
////////////////////////////////                cnt = cnt * 10 + s[i++] - '0';
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        fillAns(ans, name, pre, cnt);
////////////////////////////////        where = i;
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void fillAns(TreeMap<String, Integer> ans, StringBuilder name, TreeMap<String, Integer> pre, int cnt) {
////////////////////////////////        if (name.length() != 0 || pre != null) {
////////////////////////////////            cnt = cnt == 0 ? 1 : cnt;
////////////////////////////////            if (name.length() != 0) {
////////////////////////////////                String key = name.toString();
////////////////////////////////                ans.put(key, ans.getOrDefault(key, 0) + cnt);
////////////////////////////////            } else {
////////////////////////////////                for (String key : pre.keySet()) {
////////////////////////////////                    ans.put(key, ans.getOrDefault(key, 0) + pre.get(key) * cnt);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public String decodeString(String s) {
////////////////////////////////        char[] charArray = s.toCharArray();
////////////////////////////////        where = 0;
////////////////////////////////        return f(charArray, 0);
////////////////////////////////
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private String f(char[] s, int i) {
////////////////////////////////        StringBuilder sb = new StringBuilder();
////////////////////////////////        int cur = 0;
////////////////////////////////        while (i < s.length && s[i] != ']') {
////////////////////////////////            if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z')) {
////////////////////////////////                sb.append(s[i++]);
////////////////////////////////            } else if (s[i] >= '0' && s[i] <= '9') {
////////////////////////////////                cur = cur * 10 + s[i++] - '0';
////////////////////////////////            } else {
////////////////////////////////                String tmp = get(cur, f(s, i + 1));
////////////////////////////////                sb.append(tmp);
////////////////////////////////                cur = 0;
////////////////////////////////                i = where + 1;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        where = i;
////////////////////////////////        return sb.toString();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private String get(int cur, String str) {
////////////////////////////////        StringBuilder sb = new StringBuilder();
////////////////////////////////        for (int j = 0; j < cur; j++) {
////////////////////////////////            sb.append(str);
////////////////////////////////        }
////////////////////////////////        return sb.toString();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public List<List<Integer>> permute(int[] nums) {
////////////////////////////////        List<List<Integer>> ans = new ArrayList<>();
////////////////////////////////        backGround(nums, 0, ans);
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void backGround(int[] nums, int i, List<List<Integer>> ans) {
////////////////////////////////        if (i == nums.length) {
////////////////////////////////            List<Integer> tmp = new ArrayList<>();
////////////////////////////////            for (int k = 0; k < i; k++) {
////////////////////////////////                tmp.add(nums[k]);
////////////////////////////////            }
////////////////////////////////            ans.add(tmp);
////////////////////////////////        } else {
////////////////////////////////            HashSet<Integer> set = new HashSet<>();
////////////////////////////////            for (int j = i; j < nums.length; j++) {
////////////////////////////////                if (!set.contains(nums[j])) {
////////////////////////////////                    set.add(nums[j]);
////////////////////////////////                    swap(nums, i, j);
////////////////////////////////                    backGround(nums, i + 1, ans);
////////////////////////////////                    swap(nums, i, j);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void swap(int[] nums, int i, int j) {
////////////////////////////////        if (i != j) {
////////////////////////////////            int temp = nums[i];
////////////////////////////////            nums[i] = nums[j];
////////////////////////////////            nums[j] = temp;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public List<List<Integer>> subsetsWithDup(int[] nums) {
////////////////////////////////        List<List<Integer>> ans = new ArrayList<>();
////////////////////////////////        Arrays.sort(nums);
////////////////////////////////        backGround(nums, 0, new int[nums.length], 0, ans);
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void backGround(int[] nums, int i, int[] path, int size, List<List<Integer>> ans) {
////////////////////////////////        if (i == nums.length) {
////////////////////////////////            ArrayList<Integer> tmp = new ArrayList<>();
////////////////////////////////            for (int k = 0; k < size; k++) {
////////////////////////////////                tmp.add(path[k]);
////////////////////////////////            }
////////////////////////////////            ans.add(tmp);
////////////////////////////////        } else {
////////////////////////////////            int j = i + 1;
////////////////////////////////            while (j < nums.length && nums[j] == nums[i]) {
////////////////////////////////                j++;
////////////////////////////////            }
////////////////////////////////            backGround(nums, j, path, size, ans);
////////////////////////////////            for (; i < j; i++) {
////////////////////////////////                path[size++] = nums[i];
////////////////////////////////                backGround(nums, i, path, size, ans);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public int[] FindNumsAppearOnce(int[] nums) {
////////////////////////////////        int x = 0;
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////            x ^= nums[i];
////////////////////////////////        }
////////////////////////////////        int rightOne = x & (-x);
////////////////////////////////        int y = 0;
////////////////////////////////        for (int i = 0; i < nums.length; i++) {
////////////////////////////////
////////////////////////////////            if ((nums[i] & rightOne) != 0) {
////////////////////////////////                y ^= nums[i];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return new int[]{y, x ^ y};
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int minDepth(TreeNode root) {
////////////////////////////////        if (root == null) return 0;
////////////////////////////////        if (root.left == null && root.right == null) return 1;
////////////////////////////////        int lDepth = Integer.MAX_VALUE;
////////////////////////////////        int rDepth = Integer.MAX_VALUE;
////////////////////////////////
////////////////////////////////        if (root.left != null) {
////////////////////////////////            lDepth = Math.min(lDepth, minDepth(root.left));
////////////////////////////////        }
////////////////////////////////        if (root.right != null) {
////////////////////////////////            rDepth = Math.min(rDepth, minDepth(root.right));
////////////////////////////////        }
////////////////////////////////        return Math.min(lDepth, rDepth);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    //public static final int MAX_N = 30001;
////////////////////////////////
////////////////////////////////    public TreeNode arr[] = new TreeNode[MAX_N];
////////////////////////////////
////////////////////////////////    public int[] idq = new int[MAX_N];
////////////////////////////////
////////////////////////////////    public int l;
////////////////////////////////
////////////////////////////////    public int r;
////////////////////////////////
////////////////////////////////    public boolean reverse;
////////////////////////////////
////////////////////////////////
////////////////////////////////    public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
////////////////////////////////        if (root.val == q.val || root.val == p.val)
////////////////////////////////            return root;
////////////////////////////////        if (root.val < Math.min(p.val, q.val))
////////////////////////////////            root = lowestCommonAncestor2(root.right, p, q);
////////////////////////////////        if (root.val > Math.max(p.val, q.val))
////////////////////////////////            root = lowestCommonAncestor2(root.left, p, q);
////////////////////////////////        if (root.val < Math.max(p.val, q.val) && root.val > Math.min(p.val, q.val))
////////////////////////////////            return root;
////////////////////////////////        return root;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
////////////////////////////////        if (root == null || root == p || root == q)
////////////////////////////////            return root;
////////////////////////////////        TreeNode left = lowestCommonAncestor(root.left, p, q);
////////////////////////////////        TreeNode right = lowestCommonAncestor(root.right, p, q);
////////////////////////////////        if (left != null && right != null)
////////////////////////////////            return root;
////////////////////////////////        if (left == null && right == null) return null;
////////////////////////////////        return left == null ? right : left;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public int countNodes(TreeNode root) {
////////////////////////////////        if (root == null) return 0;
////////////////////////////////
////////////////////////////////        return f(root, 1, mostLeft(root, 1));
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int f(TreeNode root, int level, int h) {
////////////////////////////////        if (level == h) return 1;
////////////////////////////////
////////////////////////////////        if (mostLeft(root.right, level + 1) == h) {
////////////////////////////////            return (1 << (h - level)) + f(root.right, level + 1, h);
////////////////////////////////        } else {
////////////////////////////////            return (1 << (h - level - 1)) + f(root.left, level + 1, h);
////////////////////////////////        }
////////////////////////////////
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int mostLeft(TreeNode root, int level) {
////////////////////////////////        while (root != null) {
////////////////////////////////            level++;
////////////////////////////////            root = root.left;
////////////////////////////////        }
////////////////////////////////        return level - 1;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public boolean isCompleteTree(TreeNode root) {
////////////////////////////////        boolean leaf = false;
////////////////////////////////        l = r = 0;
////////////////////////////////        arr[r++] = root;
////////////////////////////////        while (l < r) {
////////////////////////////////            TreeNode cur = arr[l++];
////////////////////////////////            if (
////////////////////////////////                    (cur.left == null && cur.right != null)
////////////////////////////////                            ||
////////////////////////////////                            (leaf && (cur.left != null || cur.right != null))
////////////////////////////////            ) {
////////////////////////////////                return false;
////////////////////////////////            }
////////////////////////////////            if (cur.left != null) {
////////////////////////////////                arr[r++] = cur.left;
////////////////////////////////            }
////////////////////////////////            if (cur.right != null) {
////////////////////////////////                arr[r++] = cur.right;
////////////////////////////////            }
////////////////////////////////            if (cur.left == null || cur.right == null) {
////////////////////////////////                leaf = true;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return true;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    // Encodes a tree to a single string.
////////////////////////////////    public String serialize2(TreeNode root) {
////////////////////////////////        l = r = 0;
////////////////////////////////        StringBuilder sb = new StringBuilder();
////////////////////////////////        arr[r++] = root;
////////////////////////////////        sb.append(arr[l].val + ",");
////////////////////////////////        while (l < r) {
////////////////////////////////            TreeNode cur = arr[l++];
////////////////////////////////            if (cur.left != null) {
////////////////////////////////                arr[r++] = cur.left;
////////////////////////////////                sb.append(cur.left.val + ",");
////////////////////////////////            } else {
////////////////////////////////                sb.append("#,");
////////////////////////////////            }
////////////////////////////////            if (cur.right != null) {
////////////////////////////////                arr[r++] = cur.right;
////////////////////////////////                sb.append(cur.right.val + ",");
////////////////////////////////            } else {
////////////////////////////////                sb.append("#,");
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        return sb.toString();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    // Decodes your encoded data to tree.
////////////////////////////////    public TreeNode deserialize2(String data) {
////////////////////////////////        if (data.equals("")) return null;
////////////////////////////////        String[] values = data.split(",");
////////////////////////////////        int index = 0;
////////////////////////////////        l = r = 0;
////////////////////////////////        TreeNode root = generateNode(values[index++]);
////////////////////////////////        arr[r++] = root;
////////////////////////////////        while (l < r) {
////////////////////////////////            TreeNode cur = arr[l++];
////////////////////////////////            cur.left = generateNode(values[index++]);
////////////////////////////////            cur.right = generateNode(values[index++]);
////////////////////////////////            if (cur.left != null) {
////////////////////////////////                arr[r++] = cur.left;
////////////////////////////////            }
////////////////////////////////            if (cur.right != null) {
////////////////////////////////                arr[r++] = cur.right;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return root;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private TreeNode generateNode(String value) {
////////////////////////////////        return value.equals('#') ? null : new TreeNode(Integer.parseInt(value));
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int widthOfBinaryTree(TreeNode root) {
////////////////////////////////        if (root == null) return 0;
////////////////////////////////        int ans = 0;
////////////////////////////////        l = r = 0;
////////////////////////////////        arr[r] = root;
////////////////////////////////        idq[r++] = 1;
////////////////////////////////        while (l < r) {
////////////////////////////////            int size = r - l;
////////////////////////////////            ans = Math.max(ans, idq[r - 1] - idq[l] + 1);
////////////////////////////////            for (int i = 0; i < size; i++) {
////////////////////////////////                TreeNode cur = arr[l];
////////////////////////////////                int id = idq[l++];
////////////////////////////////                if (cur.left != null) {
////////////////////////////////                    arr[r] = cur.left;
////////////////////////////////                    idq[r++] = 2 * id;
////////////////////////////////                }
////////////////////////////////                if (cur.right != null) {
////////////////////////////////                    arr[r] = cur.right;
////////////////////////////////                    idq[r++] = 2 * id + 1;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
////////////////////////////////        reverse = false;
////////////////////////////////        List<List<Integer>> ans = new ArrayList<>();
////////////////////////////////        if (root == null) return ans;
////////////////////////////////        l = r = 0;
////////////////////////////////        arr[r++] = root;
////////////////////////////////        while (l < r) {
////////////////////////////////            int size = r - l;
////////////////////////////////            List<Integer> level = new ArrayList<>();
////////////////////////////////            for (int i = reverse ? r - 1 : l, j = reverse ? -1 : 1, k = 0; k < size; i += j, k++) {
////////////////////////////////                level.add(arr[i].val);
////////////////////////////////            }
////////////////////////////////            for (int i = 0; i < size; i++) {
////////////////////////////////                TreeNode cur = arr[l++];
////////////////////////////////                if (cur.left != null) {
////////////////////////////////                    arr[r++] = cur.left;
////////////////////////////////                }
////////////////////////////////                if (cur.right != null) {
////////////////////////////////                    arr[r++] = cur.right;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            ans.add(level);
////////////////////////////////            reverse = !reverse;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public List<List<Integer>> levelOrder(TreeNode root) {
////////////////////////////////        List<List<Integer>> ans = new ArrayList<>();
////////////////////////////////        if (root == null) return ans;
////////////////////////////////        l = r = 0;
////////////////////////////////        arr[r++] = root;
////////////////////////////////        while (l < r) {
////////////////////////////////            int size = r - l;
////////////////////////////////            List<Integer> level = new ArrayList<>();
////////////////////////////////            for (int i = 0; i < size; i++) {
////////////////////////////////                TreeNode cur = arr[l++];
////////////////////////////////                level.add(cur.val);
////////////////////////////////                if (cur.left != null) {
////////////////////////////////                    arr[r++] = cur.left;
////////////////////////////////                }
////////////////////////////////                if (cur.right != null) {
////////////////////////////////                    arr[r++] = cur.right;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            ans.add(level);
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static HashMap<Integer, int[]> map = new HashMap<>();
////////////////////////////////    public static int setAllValue;
////////////////////////////////    public static int setAllTime;
////////////////////////////////    //public static int cnt;
////////////////////////////////
////////////////////////////////    public static void put(int k, int v) {
////////////////////////////////        if (map.containsKey(k)) {
////////////////////////////////            int[] val = map.get(k);
////////////////////////////////            val[0] = v;
////////////////////////////////            val[1] = cnt++;
////////////////////////////////        } else {
////////////////////////////////            map.put(k, new int[]{v, cnt++});
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static void setAll(int v) {
////////////////////////////////        setAllTime = cnt;
////////////////////////////////        setAllValue = v;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static int get(int k) {
////////////////////////////////        if (!map.containsKey(k)) {
////////////////////////////////            return -1;
////////////////////////////////        }
////////////////////////////////        int time = map.get(k)[1];
////////////////////////////////        if (time < setAllTime) {
////////////////////////////////            return setAllValue;
////////////////////////////////        } else {
////////////////////////////////            return map.get(k)[0];
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public static int n, op, a, b;
////////////////////////////////
////////////////////////////////    public static void main(String[] args) throws IOException {
////////////////////////////////        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
////////////////////////////////        StreamTokenizer in = new StreamTokenizer(br);
////////////////////////////////        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
////////////////////////////////        while (in.nextToken() != StreamTokenizer.TT_EOF) {
////////////////////////////////            map.clear();
////////////////////////////////            setAllValue = 0;
////////////////////////////////            setAllTime = -1;
////////////////////////////////            cnt = 0;
////////////////////////////////            n = (int) in.nval;
////////////////////////////////            for (int i = 0; i < n; i++) {
////////////////////////////////                in.nextToken();
////////////////////////////////                op = (int) in.nval;
////////////////////////////////                if (op == 1) {
////////////////////////////////                    in.nextToken();
////////////////////////////////                    a = (int) in.nval;
////////////////////////////////                    in.nextToken();
////////////////////////////////                    b = (int) in.nval;
////////////////////////////////                    put(a, b);
////////////////////////////////                } else if (op == 2) {
////////////////////////////////                    in.nextToken();
////////////////////////////////                    a = (int) in.nval;
////////////////////////////////                    out.println(get(a));
////////////////////////////////                } else {
////////////////////////////////                    in.nextToken();
////////////////////////////////                    a = (int) in.nval;
////////////////////////////////                    setAll(a);
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        out.flush();
////////////////////////////////        out.close();
////////////////////////////////        br.close();
////////////////////////////////    }
////////////////////////////////
////////////////////////////////
////////////////////////////////    public boolean isPalindrome(ListNode head) {
////////////////////////////////        if (head == null || head.next == null) {
////////////////////////////////            return true;
////////////////////////////////        }
////////////////////////////////        ListNode slow = head;
////////////////////////////////        ListNode fast = head;
////////////////////////////////        while (fast.next != null && fast.next.next != null) {
////////////////////////////////            fast = fast.next.next;
////////////////////////////////            slow = slow.next;
////////////////////////////////        }
////////////////////////////////        ListNode pre = slow;
////////////////////////////////        slow.next = null;
////////////////////////////////        ListNode next = null;
////////////////////////////////        ListNode cur = pre.next;
////////////////////////////////        while (cur != null) {
////////////////////////////////            next = cur.next;
////////////////////////////////            cur.next = pre;
////////////////////////////////            pre = cur;
////////////////////////////////            cur = next;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        ListNode test = pre;
////////////////////////////////        while (test != null) {
////////////////////////////////            System.out.print(test.val + " ");
////////////////////////////////            test = test.next;
////////////////////////////////        }
////////////////////////////////        System.out.println();
////////////////////////////////        test = head;
////////////////////////////////        while (test != null) {
////////////////////////////////            System.out.print(test.val + " ");
////////////////////////////////            test = test.next;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        ListNode left = head;
////////////////////////////////        ListNode right = pre;
////////////////////////////////        boolean ans = true;
////////////////////////////////        while (left != null && right != null) {
////////////////////////////////            if (left.val != right.val) {
////////////////////////////////                ans = false;
////////////////////////////////                break;
////////////////////////////////            }
////////////////////////////////            left = left.next;
////////////////////////////////            right = right.next;
////////////////////////////////        }
////////////////////////////////        cur = pre.next;
////////////////////////////////        pre.next = null;
////////////////////////////////        while (cur != null) {
////////////////////////////////            next = cur.next;
////////////////////////////////            cur.next = pre;
////////////////////////////////            pre = cur;
////////////////////////////////            cur = next;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public Node copyRandomList(Node head) {
////////////////////////////////        if (head == null) return null;
////////////////////////////////        Node cur = head;
////////////////////////////////        while (cur != null) {
////////////////////////////////            Node node = new Node(cur.val);
////////////////////////////////            Node next = cur.next;
////////////////////////////////            node.next = next;
////////////////////////////////            cur.next = node;
////////////////////////////////            cur = cur.next.next;
////////////////////////////////        }
////////////////////////////////        cur = head;
////////////////////////////////        Node next = null;
////////////////////////////////        Node node = cur.next;
////////////////////////////////        while (cur != null) {
////////////////////////////////            next = cur.next.next;
////////////////////////////////            node = cur.next;
////////////////////////////////            node.random = cur.random != null ? cur.random.next : null;
////////////////////////////////            cur = next;
////////////////////////////////        }
////////////////////////////////        Node ans = head.next;
////////////////////////////////        cur = head;
////////////////////////////////        while (cur != null) {
////////////////////////////////            next = cur.next.next;
////////////////////////////////            node = cur.next;
////////////////////////////////            cur.next = next;
////////////////////////////////            node.next = next != null ? next.next : null;
////////////////////////////////            cur = next;
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode reverseKGroup(ListNode head, int k) {
////////////////////////////////        ListNode start = head;
////////////////////////////////        ListNode end = boolReverse(start, k);
////////////////////////////////        if (end == null) {
////////////////////////////////            return head;
////////////////////////////////        }
////////////////////////////////        head = end;
////////////////////////////////        reverseList(start, end);
////////////////////////////////        ListNode lastTeamEnd = start;
////////////////////////////////        while (lastTeamEnd.next != null) {
////////////////////////////////            start = lastTeamEnd.next;
////////////////////////////////            end = boolReverse(start, k);
////////////////////////////////            if (end == null) {
////////////////////////////////                return head;
////////////////////////////////            }
////////////////////////////////            reverseList(start, end);
////////////////////////////////            lastTeamEnd.next = end;
////////////////////////////////            lastTeamEnd = start;
////////////////////////////////        }
////////////////////////////////        return head;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode rotateRight(ListNode head, int k) {
////////////////////////////////        int size = 0;
////////////////////////////////        ListNode cur = head;
////////////////////////////////        while (cur != null) {
////////////////////////////////            cur = cur.next;
////////////////////////////////            size++;
////////////////////////////////        }
////////////////////////////////        k %= size;
////////////////////////////////        ListNode result = reverseList(head);
////////////////////////////////        cur = result;
////////////////////////////////        while (--k > 0) {
////////////////////////////////            cur = cur.next;
////////////////////////////////        }
////////////////////////////////        ListNode cur2 = cur.next;
////////////////////////////////        cur.next = null;
////////////////////////////////        ListNode ret1 = reverseList(cur);
////////////////////////////////        while (ret1 != null) {
////////////////////////////////            System.out.println(ret1.val + " ");
////////////////////////////////            ret1 = ret1.next;
////////////////////////////////        }
////////////////////////////////        System.out.println();
////////////////////////////////        ListNode ret2 = reverseList(cur2);
////////////////////////////////        while (ret2 != null) {
////////////////////////////////            System.out.println(ret2.val + " ");
////////////////////////////////            ret2 = ret2.next;
////////////////////////////////        }
////////////////////////////////        result = ret1;
////////////////////////////////        while (ret1.next != null) {
////////////////////////////////            ret1 = ret1.next;
////////////////////////////////        }
////////////////////////////////        ret1.next = ret2;
////////////////////////////////        return result;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode reverseBetween(ListNode head, int left, int right) {
////////////////////////////////        if (left == right)
////////////////////////////////            return head;
////////////////////////////////        ListNode pre = null;
////////////////////////////////        ListNode curLeft = head;
////////////////////////////////        while (--left > 0) {
////////////////////////////////            pre = curLeft;
////////////////////////////////            curLeft = curLeft.next;
////////////////////////////////        }
////////////////////////////////        ListNode endRight = head;
////////////////////////////////        while (--right > 0) {
////////////////////////////////            endRight = endRight.next;
////////////////////////////////        }
////////////////////////////////        ListNode end = endRight.next == null ? null : endRight.next;
////////////////////////////////        reverseList(curLeft, endRight);
////////////////////////////////        if (pre == null)
////////////////////////////////            head = endRight;
////////////////////////////////        else
////////////////////////////////            pre.next = endRight;
////////////////////////////////        curLeft.next = end;
////////////////////////////////        return head;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private void reverseList(ListNode start, ListNode end) {
////////////////////////////////        ListNode pre = null;
////////////////////////////////        ListNode cur = start;
////////////////////////////////        ListNode next = null;
////////////////////////////////        end = end.next == null ? null : end;
////////////////////////////////        while (cur != end) {
////////////////////////////////            next = cur.next;
////////////////////////////////            cur.next = pre;
////////////////////////////////            pre = cur;
////////////////////////////////            cur = next;
////////////////////////////////        }
////////////////////////////////        start.next = end;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private ListNode boolReverse(ListNode start, int k) {
////////////////////////////////        while (start != null && --k > 0) {
////////////////////////////////            start = start.next;
////////////////////////////////        }
////////////////////////////////        return start;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int singleNumber2(int[] nums) {
////////////////////////////////        return find(nums, 3);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private int find(int[] nums, int m) {
////////////////////////////////        int[] cnt = new int[32];
////////////////////////////////        for (int num : nums) {
////////////////////////////////            for (int i = 0; i < 32; i++) {
////////////////////////////////                cnt[i] += (num >> i) & 1;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        int ans = 0;
////////////////////////////////        for (int i = 0; i < 32; i++) {
////////////////////////////////            if (cnt[i] % m != 0) {
////////////////////////////////                ans |= 1 << i;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return ans;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    class Solution {
////////////////////////////////        public static int MAX_N = 300005;
////////////////////////////////
////////////////////////////////        public static int[][] tree = new int[MAX_N][2];
////////////////////////////////
////////////////////////////////        public static int cnt;
////////////////////////////////
////////////////////////////////        public static int left;
////////////////////////////////
////////////////////////////////        public static void build(int[] nums) {
////////////////////////////////            cnt = 1;
////////////////////////////////            int max = Integer.MIN_VALUE;
////////////////////////////////            for (int i = 0; i < nums.length; i++) {
////////////////////////////////                max = Math.max(max, nums[i]);
////////////////////////////////            }
////////////////////////////////            left = 31 - Integer.numberOfLeadingZeros(max);
////////////////////////////////            for (int i = 0; i < nums.length; i++) {
////////////////////////////////                insert(nums[i]);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static void clear() {
////////////////////////////////            for (int i = 0; i <= cnt; i++) {
////////////////////////////////                Arrays.fill(tree[i], 0);
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static void insert(int num) {
////////////////////////////////            int cur = 1;
////////////////////////////////            int index = 0;
////////////////////////////////            for (int i = left; i >= 0; i--) {
////////////////////////////////                index = (num >> i) & 1;
////////////////////////////////                if (tree[cur][index] == 0) {
////////////////////////////////                    tree[cur][index] = ++cnt;
////////////////////////////////                }
////////////////////////////////                cur = tree[cur][index];
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public static int maxXOR(int num) {
////////////////////////////////            int cur = 1;
////////////////////////////////            int index = 0;
////////////////////////////////            int ans = 0;
////////////////////////////////            int want = 0;
////////////////////////////////            for (int i = left; i >= 0; i--) {
////////////////////////////////                index = (num >> i) & 1;
////////////////////////////////                want = index ^ 1;
////////////////////////////////                if (tree[cur][want] == 0) {
////////////////////////////////                    want ^= 1;
////////////////////////////////                }
////////////////////////////////                ans = ans | ((index ^ want) << i);
////////////////////////////////                cur = tree[cur][want];
////////////////////////////////            }
////////////////////////////////            return ans;
////////////////////////////////        }
////////////////////////////////
////////////////////////////////        public int findMaximumXOR(int[] nums) {
////////////////////////////////            build(nums);
////////////////////////////////            int ans = 0;
////////////////////////////////            for (int i = 0; i < nums.length; i++) {
////////////////////////////////                ans = Math.max(ans, maxXOR(nums[i]));
////////////////////////////////            }
////////////////////////////////            clear();
////////////////////////////////            return ans;
////////////////////////////////        }
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public int[] singleNumber3(int[] nums) {
////////////////////////////////        int eor1 = 0;
////////////////////////////////        for (int num : nums) {
////////////////////////////////            eor1 ^= num;
////////////////////////////////        }
////////////////////////////////        int rightOne = eor1 & (-eor1);
////////////////////////////////        int eor2 = 0;
////////////////////////////////        for (int num : nums) {
////////////////////////////////            if ((num & rightOne) == 0) {
////////////////////////////////                eor2 ^= num;
////////////////////////////////            }
////////////////////////////////        }
////////////////////////////////        return new int[]{eor1, eor2 ^ eor1};
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode deleteDuplicates(ListNode head) {
////////////////////////////////        ListNode pre = null;
////////////////////////////////        ListNode cur = head;
////////////////////////////////        while (cur != null) {
////////////////////////////////            while (pre != null && pre.val == cur.val) {
////////////////////////////////                pre.next = cur.next;
////////////////////////////////                cur = pre.next;
////////////////////////////////                if (cur == null) {
////////////////////////////////                    break;
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////            if (cur == null) {
////////////////////////////////                break;
////////////////////////////////            }
////////////////////////////////            pre = cur;
////////////////////////////////            cur = cur.next;
////////////////////////////////        }
////////////////////////////////        return head;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode sortInList(ListNode head) {
////////////////////////////////        PriorityQueue<ListNode> heap = new PriorityQueue<>((o1, o2) -> o1.val - o2.val);
////////////////////////////////        while (head != null) {
////////////////////////////////            heap.add(head);
////////////////////////////////            head = head.next;
////////////////////////////////        }
////////////////////////////////        ListNode pre = null;
////////////////////////////////        if (!heap.isEmpty()) {
////////////////////////////////            pre = heap.poll();
////////////////////////////////        }
////////////////////////////////        head = pre;
////////////////////////////////        System.out.println("111");
////////////////////////////////        while (!heap.isEmpty()) {
////////////////////////////////            ListNode cur = heap.poll();
////////////////////////////////            cur.next = null;
////////////////////////////////            pre.next = cur;
////////////////////////////////            pre = cur;
////////////////////////////////        }
////////////////////////////////        while (head != null) {
////////////////////////////////            System.out.println(head.val);
////////////////////////////////            head = head.next;
////////////////////////////////        }
////////////////////////////////        return head;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode addInList(ListNode head1, ListNode head2) {
////////////////////////////////        head1 = reverseList(head1);
////////////////////////////////        head2 = reverseList(head2);
////////////////////////////////        head1 = addTwoList(head1, head2);
////////////////////////////////        return reverseList(head1);
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private ListNode addTwoList(ListNode head1, ListNode head2) {
////////////////////////////////        int carry = 0;
////////////////////////////////        ListNode result = head1;
////////////////////////////////        ListNode pre = null;
////////////////////////////////        while (head1 != null || head2 != null) {
////////////////////////////////            int val1 = head1 == null ? 0 : head1.val;
////////////////////////////////            int val2 = head2 == null ? 0 : head2.val;
////////////////////////////////            int sum = val1 + val2 + carry;
////////////////////////////////            carry = sum / 10;
////////////////////////////////            int val = sum % 10;
////////////////////////////////            if (head1 == null) {
////////////////////////////////                head1 = new ListNode(val);
////////////////////////////////            } else {
////////////////////////////////                head1.val = val;
////////////////////////////////            }
////////////////////////////////            head1 = head1 == null ? head1 : head1.next;
////////////////////////////////            head2 = head2 == null ? head2 : head2.next;
////////////////////////////////        }
////////////////////////////////        if (carry != 0) {
////////////////////////////////            ListNode node = new ListNode(carry);
////////////////////////////////            head1.next = node;
////////////////////////////////        }
////////////////////////////////        return result;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    private ListNode reverseList(ListNode head1) {
////////////////////////////////        ListNode cur = head1;
////////////////////////////////        ListNode pre = null;
////////////////////////////////        while (cur != null) {
////////////////////////////////            ListNode next = cur.next;
////////////////////////////////            cur.next = pre;
////////////////////////////////            pre = cur;
////////////////////////////////            cur = next;
////////////////////////////////        }
////////////////////////////////        return pre;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
////////////////////////////////        HashSet<Integer> set = new HashSet<>();
////////////////////////////////        while (pHead1 != null) {
////////////////////////////////            set.add(pHead1.val);
////////////////////////////////            pHead1 = pHead1.next;
////////////////////////////////        }
////////////////////////////////        while (pHead2 != null) {
////////////////////////////////            if (set.contains(pHead2.val)) {
////////////////////////////////                return pHead2;
////////////////////////////////            }
////////////////////////////////            pHead2 = pHead2.next;
////////////////////////////////        }
////////////////////////////////        return null;
////////////////////////////////    }
////////////////////////////////
////////////////////////////////    void lipu(HashMap<Integer, Integer> hash, int value) {
////////////////////////////////        for (int i = 1; i <= value / i; i++) {
////////////////////////////////            if (value % i == 0) {
////////////////////////////////                if (hash.containsKey(i)) {
////////////////////////////////                    hash.put(i, hash.get(i) + 1);
////////////////////////////////                } else {
////////////////////////////////                    hash.put(i, 1);
////////////////////////////////                }
////////////////////////////////                if (i != value / i) {
////////////////////////////////                    if (hash.containsKey(value / i)) {
////////////////////////////////                        hash.put(value / i, hash.get(value / i) + 1);
////////////////////////////////                    } else {
////////////////////////////////                        hash.put(value / i, 1);
////////////////////////////////                    }
////////////////////////////////                }
////////////////////////////////            }
////////////////////////////////        }
//    }
//
//    public long numberOfPairs(int[] nums1, int[] nums2, int k) {
//        long ret = 0;
//        List<Integer> value = new ArrayList<>();
//        for (int i = 0; i < nums2.length; i++) {
//            nums2[i] *= k;
//        }
//        HashMap<Integer, Integer> hash = new HashMap<>();
//        for (int i = 0; i < nums1.length; i++) {
//            lipu(hash, nums1[i]);
//        }
//        for (int i = 0; i < nums2.length; i++) {
//            ret += hash.get(nums2[i]);
//        }
//        return ret;
//    }
//}
}
